@solana/web3.js 1.24.2 → 1.28.0

package/module.flow.js

@@ -23,6 +23,10 @@ declare module "@solana/web3.js" {
    * Maximum length of derived pubkey seed
    */
   declare export var MAX_SEED_LENGTH: 32;
+
+  /**
+   * Value to be converted into public key
+   */
   declare export type PublicKeyInitData =
     | number
     | string
@@ -30,6 +34,10 @@ declare module "@solana/web3.js" {
     | Uint8Array
     | Array<number>
     | PublicKeyData;
+
+  /**
+   * JSON object representation of PublicKey class
+   */
   declare export type PublicKeyData = { ... };
 
   /**
@@ -354,7 +362,11 @@ declare module "@solana/web3.js" {
     recentBlockhash: Blockhash;
     instructions: CompiledInstruction[];
     constructor(args: MessageArgs): this;
+    isAccountSigner(index: number): boolean;
     isAccountWritable(index: number): boolean;
+    isProgramId(index: number): boolean;
+    programIds(): PublicKey[];
+    nonProgramIds(): PublicKey[];
     serialize(): Buffer;
 
     /**
@@ -618,7 +630,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;
   }
   declare export type TokenAccountsFilter =
     | {
@@ -958,9 +970,38 @@ declare module "@solana/web3.js" {
     "feature-set"?: number,
     ...
   };
+  declare 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,
+    ...
+  };
   declare export type SimulatedTransactionResponse = {
     err: TransactionError | string | null,
     logs: Array<string> | null,
+    accounts?: SimulatedTransactionAccountInfo[] | null,
+    unitsConsumed?: number,
     ...
   };
   declare export type ParsedInnerInstruction = {
@@ -1783,6 +1824,11 @@ declare module "@solana/web3.js" {
      * Optional data assigned to the account
      */
     data: T,
+
+    /**
+     * Optional rent epoch infor for account
+     */
+    rentEpoch?: number,
     ...
   };
 
@@ -2016,6 +2062,11 @@ declare module "@solana/web3.js" {
      * 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,
     ...
   };
 
@@ -2373,6 +2424,11 @@ feeCalculator: FeeCalculator,...
      */
     getVersion(): Promise<Version>;
 
+    /**
+     * Fetch the genesis hash
+     */
+    getGenesisHash(): Promise<string>;
+
     /**
      * Fetch a processed block from the cluster.
      */
@@ -2514,8 +2570,9 @@ feeCalculator: FeeCalculator,...
      * Simulate a transaction
      */
     simulateTransaction(
-      transaction: Transaction,
-      signers?: Array<Signer>
+      transactionOrMessage: Transaction | Message,
+      signers?: Array<Signer>,
+      includeAccounts?: boolean | Array<PublicKey>
     ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
 
     /**
@@ -2712,6 +2769,50 @@ feeCalculator: FeeCalculator,...
     ): Promise<boolean>;
   }
 
+  /**
+   * Params for creating an ed25519 instruction using a public key
+   */
+  declare export type CreateEd25519InstructionWithPublicKeyParams = {
+    publicKey: Uint8Array,
+    message: Uint8Array,
+    signature: Uint8Array,
+    instructionIndex?: number,
+    ...
+  };
+
+  /**
+   * Params for creating an ed25519 instruction using a private key
+   */
+  declare export type CreateEd25519InstructionWithPrivateKeyParams = {
+    privateKey: Uint8Array,
+    message: Uint8Array,
+    instructionIndex?: number,
+    ...
+  };
+  declare 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/web3.js",
-  "version": "1.24.2",
+  "version": "1.28.0",
   "description": "Solana Javascript API",
   "keywords": [
     "api",
@@ -43,7 +43,7 @@
     "clean": "rimraf ./coverage ./lib",
     "codecov": "set -ex; npm run test:cover; cat ./coverage/lcov.info | codecov",
     "dev": "cross-env NODE_ENV=development rollup -c",
-    "doc": "set -ex; typedoc",
+    "doc": "set -ex; typedoc --treatWarningsAsErrors",
     "flow:check": "flow check-contents < module.flow.js",
     "flow:gen": "flowgen lib/index.d.ts -o module.flow.js",
     "type:gen": "./scripts/typegen.sh",
@@ -68,10 +68,10 @@
     "borsh": "^0.4.0",
     "bs58": "^4.0.1",
     "buffer": "6.0.1",
+    "cross-fetch": "^3.1.4",
     "crypto-hash": "^1.2.2",
     "jayson": "^3.4.4",
     "js-sha3": "^0.8.0",
-    "node-fetch": "^2.6.1",
     "rpc-websockets": "^7.4.2",
     "secp256k1": "^4.0.2",
     "superstruct": "^0.14.2",
@@ -102,7 +102,6 @@
     "@types/mocha": "^9.0.0",
     "@types/mz": "^2.7.3",
     "@types/node": "^16.0.0",
-    "@types/node-fetch": "^2.5.8",
     "@types/secp256k1": "^4.0.1",
     "@types/sinon": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^4.14.2",
@@ -127,6 +126,7 @@
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",
     "prettier": "^2.3.0",
+    "puppeteer": "^10.2.0",
     "rimraf": "3.0.2",
     "rollup": "2.56.3",
     "rollup-plugin-dts": "^4.0.0",
@@ -137,7 +137,10 @@
     "start-server-and-test": "^1.12.0",
     "ts-node": "^10.0.0",
     "tslib": "^2.1.0",
-    "typedoc": "^0.21.0-beta.2",
+    "typedoc": "^0.22.2",
     "typescript": "^4.3.2"
+  },
+  "engines": {
+    "node": ">=12.20.0"
   }
 }

package/src/connection.ts

@@ -1,6 +1,7 @@
 import bs58 from 'bs58';
 import {Buffer} from 'buffer';
-import fetch, {Response} from 'node-fetch';
+import fetch from 'cross-fetch';
+import type {Response} from 'cross-fetch';
 import {
   type as pick,
   number,
@@ -438,15 +439,44 @@ const VersionResult = pick({
   'feature-set': optional(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;
 };
 
 const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(
   pick({
     err: nullable(union([pick({}), string()])),
     logs: nullable(array(string())),
+    accounts: optional(
+      nullable(
+        array(
+          pick({
+            executable: boolean(),
+            owner: string(),
+            lamports: number(),
+            data: array(string()),
+            rentEpoch: optional(number()),
+          }),
+        ),
+      ),
+    ),
+    unitsConsumed: optional(number()),
   }),
 );
 
@@ -1678,6 +1708,8 @@ export type AccountInfo<T> = {
   lamports: number;
   /** Optional data assigned to the account */
   data: T;
+  /** Optional rent epoch infor for account */
+  rentEpoch?: number;
 };
 
 /**
@@ -1947,6 +1979,8 @@ export type ConnectionConfig = {
   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;
 };
 
 /**
@@ -1954,6 +1988,7 @@ export type ConnectionConfig = {
  */
 export class Connection {
   /** @internal */ _commitment?: Commitment;
+  /** @internal */ _confirmTransactionInitialTimeout?: number;
   /** @internal */ _rpcEndpoint: string;
   /** @internal */ _rpcWsEndpoint: string;
   /** @internal */ _rpcClient: RpcClient;
@@ -2038,6 +2073,8 @@ export 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;
@@ -2597,14 +2634,14 @@ export class Connection {
       }
     });
 
-    let timeoutMs = 60 * 1000;
+    let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
     switch (subscriptionCommitment) {
       case 'processed':
       case 'recent':
       case 'single':
       case 'confirmed':
       case 'singleGossip': {
-        timeoutMs = 30 * 1000;
+        timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
         break;
       }
       // exhaust enums to ensure full coverage
@@ -2962,6 +2999,18 @@ export class Connection {
     return res.result;
   }
 
+  /**
+   * Fetch the genesis hash
+   */
+  async getGenesisHash(): Promise<string> {
+    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.
    */
@@ -3417,9 +3466,17 @@ export class Connection {
    * Simulate a transaction
    */
   async simulateTransaction(
-    transaction: Transaction,
+    transactionOrMessage: Transaction | Message,
     signers?: Array<Signer>,
+    includeAccounts?: boolean | Array<PublicKey>,
   ): Promise<RpcResponseAndContext<SimulatedTransactionResponse>> {
+    let transaction;
+    if (transactionOrMessage instanceof Transaction) {
+      transaction = transactionOrMessage;
+    } else {
+      transaction = Transaction.populate(transactionOrMessage);
+    }
+
     if (transaction.nonceInfo && signers) {
       transaction.sign(...signers);
     } else {
@@ -3453,7 +3510,8 @@ export class Connection {
       }
     }
 
-    const signData = transaction.serializeMessage();
+    const message = transaction._compile();
+    const signData = message.serialize();
     const wireTransaction = transaction._serialize(signData);
     const encodedTransaction = wireTransaction.toString('base64');
     const config: any = {
@@ -3461,6 +3519,19 @@ export 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;
     }

package/src/ed25519-program.ts

@@ -0,0 +1,140 @@
+import {Buffer} from 'buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+import nacl from 'tweetnacl';
+
+import {Keypair} from './keypair';
+import {PublicKey} from './publickey';
+import {TransactionInstruction} from './transaction';
+import assert from './util/assert';
+
+const PRIVATE_KEY_BYTES = 64;
+const PUBLIC_KEY_BYTES = 32;
+const SIGNATURE_BYTES = 64;
+
+/**
+ * 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;
+};
+
+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'),
+]);
+
+export class Ed25519Program {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Public key that identifies the ed25519 program
+   */
+  static programId: PublicKey = new PublicKey(
+    'Ed25519SigVerify111111111111111111111111111',
+  );
+
+  /**
+   * 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 {
+    const {publicKey, message, signature, instructionIndex} = params;
+
+    assert(
+      publicKey.length === PUBLIC_KEY_BYTES,
+      `Public Key must be ${PUBLIC_KEY_BYTES} 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: CreateEd25519InstructionWithPrivateKeyParams,
+  ): TransactionInstruction {
+    const {privateKey, message, instructionIndex} = params;
+
+    assert(
+      privateKey.length === PRIVATE_KEY_BYTES,
+      `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${privateKey.length} bytes`,
+    );
+
+    try {
+      const keypair = Keypair.fromSecretKey(privateKey);
+      const publicKey = keypair.publicKey.toBytes();
+      const signature = nacl.sign.detached(message, keypair.secretKey);
+
+      return this.createInstructionWithPublicKey({
+        publicKey,
+        message,
+        signature,
+        instructionIndex,
+      });
+    } catch (error) {
+      throw new Error(`Error creating instruction; ${error}`);
+    }
+  }
+}

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './bpf-loader-deprecated';
 export * from './bpf-loader';
 export * from './connection';
 export * from './epoch-schedule';
+export * from './ed25519-program';
 export * from './fee-calculator';
 export * from './keypair';
 export * from './loader';

package/src/message.ts

@@ -65,11 +65,26 @@ export class Message {
   recentBlockhash: Blockhash;
   instructions: CompiledInstruction[];
 
+  private indexToProgramIds: Map<number, PublicKey> = new Map<
+    number,
+    PublicKey
+  >();
+
   constructor(args: MessageArgs) {
     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: number): boolean {
+    return index < this.header.numRequiredSignatures;
   }
 
   isAccountWritable(index: number): boolean {
@@ -83,6 +98,18 @@ export class Message {
     );
   }
 
+  isProgramId(index: number): boolean {
+    return this.indexToProgramIds.has(index);
+  }
+
+  programIds(): PublicKey[] {
+    return [...this.indexToProgramIds.values()];
+  }
+
+  nonProgramIds(): PublicKey[] {
+    return this.accountKeys.filter((_, index) => !this.isProgramId(index));
+  }
+
   serialize(): Buffer {
     const numKeys = this.accountKeys.length;
 

package/src/publickey.ts

@@ -12,7 +12,10 @@ import {toBuffer} from './util/to-buffer';
  */
 export const MAX_SEED_LENGTH = 32;
 
-type PublicKeyInitData =
+/**
+ * Value to be converted into public key
+ */
+export type PublicKeyInitData =
   | number
   | string
   | Buffer
@@ -20,7 +23,10 @@ type PublicKeyInitData =
   | Array<number>
   | PublicKeyData;
 
-type PublicKeyData = {
+/**
+ * JSON object representation of PublicKey class
+ */
+export type PublicKeyData = {
   /** @internal */
   _bn: BN;
 };

package/src/transaction.ts

@@ -106,7 +106,7 @@ export type SignaturePubkeyPair = {
  * List of Transaction object fields that may be initialized at construction
  *
  */
-type TransactionCtorFields = {
+export type TransactionCtorFields = {
   /** A recent blockhash */
   recentBlockhash?: Blockhash | null;
   /** Optional nonce information used for offline nonce'd transactions */
@@ -120,7 +120,7 @@ type TransactionCtorFields = {
 /**
  * Nonce information to be used to build an offline Transaction.
  */
-type NonceInformation = {
+export type NonceInformation = {
   /** The current blockhash stored in the nonce */
   nonce: Blockhash;
   /** AdvanceNonceAccount Instruction */
@@ -666,7 +666,10 @@ export class Transaction {
   /**
    * Populate Transaction object from message and signatures
    */
-  static populate(message: Message, signatures: Array<string>): Transaction {
+  static populate(
+    message: Message,
+    signatures: Array<string> = [],
+  ): Transaction {
     const transaction = new Transaction();
     transaction.recentBlockhash = message.recentBlockhash;
     if (message.header.numRequiredSignatures > 0) {
@@ -688,9 +691,10 @@ export 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),
         };
       });