@solana/web3.js 1.24.2 → 1.28.0

package/lib/index.d.ts

@@ -18,6 +18,9 @@ declare module '@solana/web3.js' {
    * Maximum length of derived pubkey seed
    */
   export const MAX_SEED_LENGTH = 32;
+  /**
+   * Value to be converted into public key
+   */
   export type PublicKeyInitData =
     | number
     | string
@@ -25,6 +28,9 @@ declare module '@solana/web3.js' {
     | Uint8Array
     | Array<number>
     | PublicKeyData;
+  /**
+   * JSON object representation of PublicKey class
+   */
   export type PublicKeyData = {};
   /**
    * A public key
@@ -296,8 +302,13 @@ declare module '@solana/web3.js' {
     accountKeys: PublicKey[];
     recentBlockhash: Blockhash;
     instructions: CompiledInstruction[];
+    private indexToProgramIds;
     constructor(args: MessageArgs);
+    isAccountSigner(index: number): boolean;
     isAccountWritable(index: number): boolean;
+    isProgramId(index: number): boolean;
+    programIds(): PublicKey[];
+    nonProgramIds(): PublicKey[];
     serialize(): Buffer;
     /**
      * Decode a compiled message into a Message object.
@@ -499,7 +510,7 @@ declare module '@solana/web3.js' {
     /**
      * Populate Transaction object from message and signatures
      */
-    static populate(message: Message, signatures: Array<string>): Transaction;
+    static populate(message: Message, signatures?: Array<string>): Transaction;
   }
 
   export type TokenAccountsFilter =
@@ -714,9 +725,23 @@ declare module '@solana/web3.js' {
     'solana-core': string;
     'feature-set'?: number;
   };
+  export type SimulatedTransactionAccountInfo = {
+    /** `true` if this account's data contains a loaded program */
+    executable: boolean;
+    /** Identifier of the program that owns the account */
+    owner: string;
+    /** Number of lamports assigned to the account */
+    lamports: number;
+    /** Optional data assigned to the account */
+    data: string[];
+    /** Optional rent epoch info for account */
+    rentEpoch?: number;
+  };
   export type SimulatedTransactionResponse = {
     err: TransactionError | string | null;
     logs: Array<string> | null;
+    accounts?: SimulatedTransactionAccountInfo[] | null;
+    unitsConsumed?: number;
   };
   export type ParsedInnerInstruction = {
     index: number;
@@ -1166,6 +1191,8 @@ declare module '@solana/web3.js' {
     lamports: number;
     /** Optional data assigned to the account */
     data: T;
+    /** Optional rent epoch infor for account */
+    rentEpoch?: number;
   };
   /**
    * Account information identified by pubkey
@@ -1328,6 +1355,8 @@ declare module '@solana/web3.js' {
     fetchMiddleware?: FetchMiddleware;
     /** Optional Disable retring calls when server responds with HTTP 429 (Too Many Requests) */
     disableRetryOnRateLimit?: boolean;
+    /** time to allow for the server to initially process a transaction (in milliseconds) */
+    confirmTransactionInitialTimeout?: number;
   };
   /**
    * A connection to a fullnode JSON RPC endpoint
@@ -1624,6 +1653,10 @@ declare module '@solana/web3.js' {
      * Fetch the node version
      */
     getVersion(): Promise<Version>;
+    /**
+     * Fetch the genesis hash
+     */
+    getGenesisHash(): Promise<string>;
     /**
      * Fetch a processed block from the cluster.
      */
@@ -1757,8 +1790,9 @@ declare module '@solana/web3.js' {
      * Simulate a transaction
      */
     simulateTransaction(
-      transaction: Transaction,
+      transactionOrMessage: Transaction | Message,
       signers?: Array<Signer>,
+      includeAccounts?: boolean | Array<PublicKey>,
     ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
     /**
      * Sign and send a transaction
@@ -1952,6 +1986,45 @@ declare module '@solana/web3.js' {
     ): Promise<boolean>;
   }
 
+  /**
+   * Params for creating an ed25519 instruction using a public key
+   */
+  export type CreateEd25519InstructionWithPublicKeyParams = {
+    publicKey: Uint8Array;
+    message: Uint8Array;
+    signature: Uint8Array;
+    instructionIndex?: number;
+  };
+  /**
+   * Params for creating an ed25519 instruction using a private key
+   */
+  export type CreateEd25519InstructionWithPrivateKeyParams = {
+    privateKey: Uint8Array;
+    message: Uint8Array;
+    instructionIndex?: number;
+  };
+  export class Ed25519Program {
+    /**
+     * Public key that identifies the ed25519 program
+     */
+    static programId: PublicKey;
+    /**
+     * Create an ed25519 instruction with a public key and signature. The
+     * public key must be a buffer that is 32 bytes long, and the signature
+     * must be a buffer of 64 bytes.
+     */
+    static createInstructionWithPublicKey(
+      params: CreateEd25519InstructionWithPublicKeyParams,
+    ): TransactionInstruction;
+    /**
+     * Create an ed25519 instruction with a private key. The private key
+     * must be a buffer that is 64 bytes long.
+     */
+    static createInstructionWithPrivateKey(
+      params: CreateEd25519InstructionWithPrivateKeyParams,
+    ): TransactionInstruction;
+  }
+
   /**
    * Program loader interface
    */

package/lib/index.esm.js

@@ -7,7 +7,7 @@ import bs58 from 'bs58';
 import { sha256 } from 'crypto-hash';
 import { serialize, deserialize, deserializeUnchecked } from 'borsh';
 import * as BufferLayout from '@solana/buffer-layout';
-import fetch from 'node-fetch';
+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$1 } from 'superstruct';
 import { Client } from 'rpc-websockets';
 import RpcClient from 'jayson/lib/client/browser';
@@ -69,6 +69,9 @@ const SOLANA_SCHEMA = new Map();
  */
 
 const MAX_SEED_LENGTH = 32;
+/**
+ * Value to be converted into public key
+ */
 
 function isPublicKeyData(value) {
   return value._bn !== undefined;
@@ -458,16 +461,35 @@ class Message {
 
     _defineProperty(this, "instructions", void 0);
 
+    _defineProperty(this, "indexToProgramIds", new Map());
+
     this.header = args.header;
     this.accountKeys = args.accountKeys.map(account => new PublicKey(account));
     this.recentBlockhash = args.recentBlockhash;
     this.instructions = args.instructions;
+    this.instructions.forEach(ix => this.indexToProgramIds.set(ix.programIdIndex, this.accountKeys[ix.programIdIndex]));
+  }
+
+  isAccountSigner(index) {
+    return index < this.header.numRequiredSignatures;
   }
 
   isAccountWritable(index) {
     return index < this.header.numRequiredSignatures - this.header.numReadonlySignedAccounts || index >= this.header.numRequiredSignatures && index < this.accountKeys.length - this.header.numReadonlyUnsignedAccounts;
   }
 
+  isProgramId(index) {
+    return this.indexToProgramIds.has(index);
+  }
+
+  programIds() {
+    return [...this.indexToProgramIds.values()];
+  }
+
+  nonProgramIds() {
+    return this.accountKeys.filter((_, index) => !this.isProgramId(index));
+  }
+
   serialize() {
     const numKeys = this.accountKeys.length;
     let keyCount = [];
@@ -1182,7 +1204,7 @@ class Transaction {
    */
 
 
-  static populate(message, signatures) {
+  static populate(message, signatures = []) {
     const transaction = new Transaction();
     transaction.recentBlockhash = message.recentBlockhash;
 
@@ -1202,7 +1224,7 @@ class Transaction {
         const pubkey = message.accountKeys[account];
         return {
           pubkey,
-          isSigner: transaction.signatures.some(keyObj => keyObj.publicKey.toString() === pubkey.toString()),
+          isSigner: transaction.signatures.some(keyObj => keyObj.publicKey.toString() === pubkey.toString()) || message.isAccountSigner(account),
           isWritable: message.isAccountWritable(account)
         };
       });
@@ -2634,7 +2656,15 @@ const VersionResult = type({
 });
 const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(type({
   err: nullable(union([type({}), string()])),
-  logs: nullable(array(string()))
+  logs: nullable(array(string())),
+  accounts: optional(nullable(array(type({
+    executable: boolean(),
+    owner: string(),
+    lamports: number(),
+    data: array(string()),
+    rentEpoch: optional(number())
+  })))),
+  unitsConsumed: optional(number())
 }));
 
 function createRpcClient(url, useHttps, httpHeaders, fetchMiddleware, disableRetryOnRateLimit) {
@@ -3366,6 +3396,8 @@ class Connection {
 
   /** @internal */
 
+  /** @internal */
+
   /**
    * Establish a JSON RPC connection
    *
@@ -3375,6 +3407,8 @@ class Connection {
   constructor(endpoint, commitmentOrConfig) {
     _defineProperty(this, "_commitment", void 0);
 
+    _defineProperty(this, "_confirmTransactionInitialTimeout", void 0);
+
     _defineProperty(this, "_rpcEndpoint", void 0);
 
     _defineProperty(this, "_rpcWsEndpoint", void 0);
@@ -3443,6 +3477,7 @@ class Connection {
       this._commitment = commitmentOrConfig;
     } else if (commitmentOrConfig) {
       this._commitment = commitmentOrConfig.commitment;
+      this._confirmTransactionInitialTimeout = commitmentOrConfig.confirmTransactionInitialTimeout;
       wsEndpoint = commitmentOrConfig.wsEndpoint;
       httpHeaders = commitmentOrConfig.httpHeaders;
       fetchMiddleware = commitmentOrConfig.fetchMiddleware;
@@ -3902,7 +3937,7 @@ class Connection {
         reject(err);
       }
     });
-    let timeoutMs = 60 * 1000;
+    let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
 
     switch (subscriptionCommitment) {
       case 'processed':
@@ -3911,7 +3946,7 @@ class Connection {
       case 'confirmed':
       case 'singleGossip':
         {
-          timeoutMs = 30 * 1000;
+          timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
           break;
         }
     }
@@ -4283,6 +4318,21 @@ class Connection {
 
     return res.result;
   }
+  /**
+   * Fetch the genesis hash
+   */
+
+
+  async getGenesisHash() {
+    const unsafeRes = await this._rpcRequest('getGenesisHash', []);
+    const res = create(unsafeRes, jsonRpcResult(string()));
+
+    if ('error' in res) {
+      throw new Error('failed to get genesis hash: ' + res.error.message);
+    }
+
+    return res.result;
+  }
   /**
    * Fetch a processed block from the cluster.
    */
@@ -4683,7 +4733,15 @@ class Connection {
    */
 
 
-  async simulateTransaction(transaction, signers) {
+  async simulateTransaction(transactionOrMessage, signers, includeAccounts) {
+    let transaction;
+
+    if (transactionOrMessage instanceof Transaction) {
+      transaction = transactionOrMessage;
+    } else {
+      transaction = Transaction.populate(transactionOrMessage);
+    }
+
     if (transaction.nonceInfo && signers) {
       transaction.sign(...signers);
     } else {
@@ -4716,7 +4774,9 @@ class Connection {
       }
     }
 
-    const signData = transaction.serializeMessage();
+    const message = transaction._compile();
+
+    const signData = message.serialize();
 
     const wireTransaction = transaction._serialize(signData);
 
@@ -4726,6 +4786,14 @@ class Connection {
       commitment: this.commitment
     };
 
+    if (includeAccounts) {
+      const addresses = (Array.isArray(includeAccounts) ? includeAccounts : message.nonProgramIds()).map(key => key.toBase58());
+      config['accounts'] = {
+        encoding: 'base64',
+        addresses
+      };
+    }
+
     if (signers) {
       config.sigVerify = true;
     }
@@ -5606,6 +5674,96 @@ class Keypair {
 
 }
 
+const PRIVATE_KEY_BYTES$1 = 64;
+const PUBLIC_KEY_BYTES$1 = 32;
+const SIGNATURE_BYTES = 64;
+/**
+ * Params for creating an ed25519 instruction using a public key
+ */
+
+const ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct([BufferLayout.u8('numSignatures'), BufferLayout.u8('padding'), BufferLayout.u16('signatureOffset'), BufferLayout.u16('signatureInstructionIndex'), BufferLayout.u16('publicKeyOffset'), BufferLayout.u16('publicKeyInstructionIndex'), BufferLayout.u16('messageDataOffset'), BufferLayout.u16('messageDataSize'), BufferLayout.u16('messageInstructionIndex')]);
+class Ed25519Program {
+  /**
+   * @internal
+   */
+  constructor() {}
+  /**
+   * Public key that identifies the ed25519 program
+   */
+
+
+  /**
+   * Create an ed25519 instruction with a public key and signature. The
+   * public key must be a buffer that is 32 bytes long, and the signature
+   * must be a buffer of 64 bytes.
+   */
+  static createInstructionWithPublicKey(params) {
+    const {
+      publicKey,
+      message,
+      signature,
+      instructionIndex
+    } = params;
+    assert(publicKey.length === PUBLIC_KEY_BYTES$1, `Public Key must be ${PUBLIC_KEY_BYTES$1} bytes but received ${publicKey.length} bytes`);
+    assert(signature.length === SIGNATURE_BYTES, `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`);
+    const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;
+    const signatureOffset = publicKeyOffset + publicKey.length;
+    const messageDataOffset = signatureOffset + signature.length;
+    const numSignatures = 1;
+    const instructionData = Buffer.alloc(messageDataOffset + message.length);
+    ED25519_INSTRUCTION_LAYOUT.encode({
+      numSignatures,
+      padding: 0,
+      signatureOffset,
+      signatureInstructionIndex: instructionIndex,
+      publicKeyOffset,
+      publicKeyInstructionIndex: instructionIndex,
+      messageDataOffset,
+      messageDataSize: message.length,
+      messageInstructionIndex: instructionIndex
+    }, instructionData);
+    instructionData.fill(publicKey, publicKeyOffset);
+    instructionData.fill(signature, signatureOffset);
+    instructionData.fill(message, messageDataOffset);
+    return new TransactionInstruction({
+      keys: [],
+      programId: Ed25519Program.programId,
+      data: instructionData
+    });
+  }
+  /**
+   * Create an ed25519 instruction with a private key. The private key
+   * must be a buffer that is 64 bytes long.
+   */
+
+
+  static createInstructionWithPrivateKey(params) {
+    const {
+      privateKey,
+      message,
+      instructionIndex
+    } = params;
+    assert(privateKey.length === PRIVATE_KEY_BYTES$1, `Private key must be ${PRIVATE_KEY_BYTES$1} bytes but received ${privateKey.length} bytes`);
+
+    try {
+      const keypair = Keypair.fromSecretKey(privateKey);
+      const publicKey = keypair.publicKey.toBytes();
+      const signature = nacl__default.sign.detached(message, keypair.secretKey);
+      return this.createInstructionWithPublicKey({
+        publicKey,
+        message,
+        signature,
+        instructionIndex
+      });
+    } catch (error) {
+      throw new Error(`Error creating instruction; ${error}`);
+    }
+  }
+
+}
+
+_defineProperty(Ed25519Program, "programId", new PublicKey('Ed25519SigVerify111111111111111111111111111'));
+
 /**
  * Address of the stake config account which configures the rate
  * of stake warmup and cooldown as well as the slashing penalty.
@@ -6738,5 +6896,5 @@ function clusterApiUrl(cluster, tls) {
 
 const LAMPORTS_PER_SOL = 1000000000;
 
-export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, Connection, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
+export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.esm.js.map