@solana/web3.js 1.26.1 → 1.27.1

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 = { ... };
 
   /**
@@ -2717,6 +2725,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.26.1",
+  "version": "1.27.1",
   "description": "Solana Javascript API",
   "keywords": [
     "api",
@@ -101,6 +101,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",
@@ -111,7 +112,7 @@
     "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": {
@@ -124,7 +125,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",

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/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

@@ -107,7 +107,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 */
@@ -121,7 +121,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 */