@aptos-labs/ts-sdk 1.8.0 → 1.9.1-plugin.0

package/src/core/crypto/ed25519.ts

@@ -2,12 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import nacl from "tweetnacl";
-import { PublicKey, PrivateKey, Signature } from "./asymmetricCrypto";
 import { Deserializer } from "../../bcs/deserializer";
-import { Serializer } from "../../bcs/serializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { AuthenticationKey } from "../authenticationKey";
 import { Hex } from "../hex";
-import { HexInput } from "../../types";
+import { HexInput, SigningScheme as AuthenticationKeyScheme } from "../../types";
 import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from "./hdKey";
+import { PrivateKey } from "./privateKey";
+import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { Signature } from "./signature";
 
 /**
  * Represents the public key of an Ed25519 key pair.
@@ -18,7 +21,7 @@ import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSee
  * Ed25519 scheme is represented in the SDK as `Legacy authentication key` and also
  * as `AnyPublicKey` that represents any `Unified authentication key`
  */
-export class Ed25519PublicKey extends PublicKey {
+export class Ed25519PublicKey extends AccountPublicKey {
   /**
    * Length of an Ed25519 public key
    */
@@ -45,6 +48,32 @@ export class Ed25519PublicKey extends PublicKey {
     this.key = hex;
   }
 
+  // region AccountPublicKey
+
+  /**
+   * Verifies a signed data with a public key
+   * @param args.message a signed message
+   * @param args.signature the signature of the message
+   */
+  verifySignature(args: VerifySignatureArgs): boolean {
+    const { message, signature } = args;
+    if (!(signature instanceof Ed25519Signature)) {
+      return false;
+    }
+
+    const messageBytes = Hex.fromHexInput(message).toUint8Array();
+    const signatureBytes = signature.toUint8Array();
+    const publicKeyBytes = this.key.toUint8Array();
+    return nacl.sign.detached.verify(messageBytes, signatureBytes, publicKeyBytes);
+  }
+
+  authKey(): AuthenticationKey {
+    return AuthenticationKey.fromSchemeAndBytes({
+      scheme: AuthenticationKeyScheme.Ed25519,
+      input: this.toUint8Array(),
+    });
+  }
+
   /**
    * Get the public key in bytes (Uint8Array).
    *
@@ -54,26 +83,9 @@ export class Ed25519PublicKey extends PublicKey {
     return this.key.toUint8Array();
   }
 
-  /**
-   * Get the public key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the public key
-   */
-  toString(): string {
-    return this.key.toString();
-  }
+  // endregion
 
-  /**
-   * Verifies a signed data with a public key
-   * @param args.message a signed message
-   * @param args.signature the signature of the message
-   */
-  verifySignature(args: { message: HexInput; signature: Ed25519Signature }): boolean {
-    const { message, signature } = args;
-    const rawMessage = Hex.fromHexInput(message).toUint8Array();
-    const rawSignature = signature.toUint8Array();
-    return nacl.sign.detached.verify(rawMessage, rawSignature, this.key.toUint8Array());
-  }
+  // region Serializable
 
   serialize(serializer: Serializer): void {
     serializer.serializeBytes(this.key.toUint8Array());
@@ -84,13 +96,12 @@ export class Ed25519PublicKey extends PublicKey {
     return new Ed25519PublicKey(bytes);
   }
 
-  static load(deserializer: Deserializer): Ed25519PublicKey {
-    const bytes = deserializer.deserializeBytes();
-    return new Ed25519PublicKey(bytes);
-  }
+  // endregion
 
-  // TODO(greg): Currently, we can't put this on the abstract type, because of a circular dependency
-  static isPublicKey(publicKey: PublicKey): publicKey is Ed25519PublicKey {
+  /**
+   * @deprecated use `instanceof Ed25519PublicKey` instead.
+   */
+  static isPublicKey(publicKey: AccountPublicKey): publicKey is Ed25519PublicKey {
     return publicKey instanceof Ed25519PublicKey;
   }
 }
@@ -98,7 +109,7 @@ export class Ed25519PublicKey extends PublicKey {
 /**
  * Represents the private key of an Ed25519 key pair.
  */
-export class Ed25519PrivateKey extends PrivateKey {
+export class Ed25519PrivateKey extends Serializable implements PrivateKey {
   /**
    * Length of an Ed25519 private key
    */
@@ -116,6 +127,8 @@ export class Ed25519PrivateKey extends PrivateKey {
    */
   private readonly signingKeyPair: nacl.SignKeyPair;
 
+  // region Constructors
+
   /**
    * Create a new PrivateKey instance from a Uint8Array or String.
    *
@@ -133,45 +146,6 @@ export class Ed25519PrivateKey extends PrivateKey {
     this.signingKeyPair = nacl.sign.keyPair.fromSeed(privateKeyHex.toUint8Array().slice(0, Ed25519PrivateKey.LENGTH));
   }
 
-  /**
-   * Get the private key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the private key
-   */
-  toUint8Array(): Uint8Array {
-    return this.signingKeyPair.secretKey.slice(0, Ed25519PrivateKey.LENGTH);
-  }
-
-  /**
-   * Get the private key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the private key
-   */
-  toString(): string {
-    return Hex.fromHexInput(this.toUint8Array()).toString();
-  }
-
-  /**
-   * Sign the given message with the private key.
-   *
-   * @param message in HexInput format
-   * @returns Signature
-   */
-  sign(message: HexInput): Ed25519Signature {
-    const hex = Hex.fromHexInput(message);
-    const signature = nacl.sign.detached(hex.toUint8Array(), this.signingKeyPair.secretKey);
-    return new Ed25519Signature(signature);
-  }
-
-  serialize(serializer: Serializer): void {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-
-  static deserialize(deserializer: Deserializer): Ed25519PrivateKey {
-    const bytes = deserializer.deserializeBytes();
-    return new Ed25519PrivateKey(bytes);
-  }
-
   /**
    * Generate a new random private key.
    *
@@ -182,16 +156,6 @@ export class Ed25519PrivateKey extends PrivateKey {
     return new Ed25519PrivateKey(keyPair.secretKey.slice(0, Ed25519PrivateKey.LENGTH));
   }
 
-  /**
-   * Derive the Ed25519PublicKey for this private key.
-   *
-   * @returns Ed25519PublicKey
-   */
-  publicKey(): Ed25519PublicKey {
-    const bytes = this.signingKeyPair.publicKey;
-    return new Ed25519PublicKey(bytes);
-  }
-
   /**
    * Derives a private key from a mnemonic seed phrase.
    *
@@ -232,6 +196,68 @@ export class Ed25519PrivateKey extends PrivateKey {
     return new Ed25519PrivateKey(privateKey);
   }
 
+  // endregion
+
+  // region PrivateKey
+
+  /**
+   * Derive the Ed25519PublicKey for this private key.
+   *
+   * @returns Ed25519PublicKey
+   */
+  publicKey(): Ed25519PublicKey {
+    const bytes = this.signingKeyPair.publicKey;
+    return new Ed25519PublicKey(bytes);
+  }
+
+  /**
+   * Sign the given message with the private key.
+   *
+   * @param message in HexInput format
+   * @returns Signature
+   */
+  sign(message: HexInput): Ed25519Signature {
+    const messageBytes = Hex.fromHexInput(message).toUint8Array();
+    const signatureBytes = nacl.sign.detached(messageBytes, this.signingKeyPair.secretKey);
+    return new Ed25519Signature(signatureBytes);
+  }
+
+  /**
+   * Get the private key in bytes (Uint8Array).
+   *
+   * @returns Uint8Array representation of the private key
+   */
+  toUint8Array(): Uint8Array {
+    return this.signingKeyPair.secretKey.slice(0, Ed25519PrivateKey.LENGTH);
+  }
+
+  /**
+   * Get the private key as a hex string with the 0x prefix.
+   *
+   * @returns string representation of the private key
+   */
+  toString(): string {
+    return Hex.fromHexInput(this.toUint8Array()).toString();
+  }
+
+  // endregion
+
+  // region Serializable
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.toUint8Array());
+  }
+
+  static deserialize(deserializer: Deserializer): Ed25519PrivateKey {
+    const bytes = deserializer.deserializeBytes();
+    return new Ed25519PrivateKey(bytes);
+  }
+
+  // endregion
+
+  /**
+   * @deprecated use `instanceof Ed25519PrivateKey` instead.
+   */
   static isPrivateKey(privateKey: PrivateKey): privateKey is Ed25519PrivateKey {
     return privateKey instanceof Ed25519PrivateKey;
   }
@@ -252,33 +278,28 @@ export class Ed25519Signature extends Signature {
    */
   private readonly data: Hex;
 
+  // region Constructors
+
   constructor(hexInput: HexInput) {
     super();
-    const hex = Hex.fromHexInput(hexInput);
-    if (hex.toUint8Array().length !== Ed25519Signature.LENGTH) {
+    const data = Hex.fromHexInput(hexInput);
+    if (data.toUint8Array().length !== Ed25519Signature.LENGTH) {
       throw new Error(`Signature length should be ${Ed25519Signature.LENGTH}`);
     }
-
-    this.data = hex;
+    this.data = data;
   }
 
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
+  // endregion
+
+  // region Signature
+
   toUint8Array(): Uint8Array {
     return this.data.toUint8Array();
   }
 
-  /**
-   * Get the signature as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the signature
-   */
-  toString(): string {
-    return this.data.toString();
-  }
+  // endregion
+
+  // region Serializable
 
   serialize(serializer: Serializer): void {
     serializer.serializeBytes(this.data.toUint8Array());
@@ -289,12 +310,5 @@ export class Ed25519Signature extends Signature {
     return new Ed25519Signature(bytes);
   }
 
-  static load(deserializer: Deserializer): Ed25519Signature {
-    const bytes = deserializer.deserializeBytes();
-    return new Ed25519Signature(bytes);
-  }
-
-  static isSignature(signature: Signature): signature is Ed25519Signature {
-    return signature instanceof Ed25519Signature;
-  }
+  // endregion
 }

package/src/core/crypto/index.ts

@@ -1,11 +1,12 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-export * from "./asymmetricCrypto";
 export * from "./ed25519";
+export * from "./hdKey";
 export * from "./multiEd25519";
-export * from "./secp256k1";
 export * from "./multiKey";
-export * from "./hdKey";
-export * from "./anyPublicKey";
-export * from "./anySignature";
+export * from "./privateKey";
+export * from "./publicKey";
+export * from "./secp256k1";
+export * from "./signature";
+export * from "./singleKey";

package/src/core/crypto/multiEd25519.ts

@@ -1,17 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { PublicKey, Signature } from "./asymmetricCrypto";
-import { Deserializer } from "../../bcs/deserializer";
-import { Serializer } from "../../bcs/serializer";
+import { Deserializer, Serializer } from "../../bcs";
+import { SigningScheme as AuthenticationKeyScheme } from "../../types";
+import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { Hex } from "../hex";
-import { HexInput } from "../../types";
+import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { Signature } from "./signature";
 
 /**
  * Represents the public key of a K-of-N Ed25519 multi-sig transaction.
  */
-export class MultiEd25519PublicKey extends PublicKey {
+export class MultiEd25519PublicKey extends AccountPublicKey {
   /**
    * Maximum number of public keys supported
    */
@@ -28,7 +28,7 @@ export class MultiEd25519PublicKey extends PublicKey {
   static readonly MIN_THRESHOLD = 1;
 
   /**
-   * List of Ed25519 public keys for this MultiEd25519PublicKey
+   * List of Ed25519 public keys for this LegacyMultiEd25519PublicKey
    */
   public readonly publicKeys: Ed25519PublicKey[];
 
@@ -50,13 +50,13 @@ export class MultiEd25519PublicKey extends PublicKey {
    */
   constructor(args: { publicKeys: Ed25519PublicKey[]; threshold: number }) {
     super();
-
     const { publicKeys, threshold } = args;
 
     // Validate number of public keys
     if (publicKeys.length > MultiEd25519PublicKey.MAX_KEYS || publicKeys.length < MultiEd25519PublicKey.MIN_KEYS) {
       throw new Error(
-        `Must have between ${MultiEd25519PublicKey.MIN_KEYS} and ${MultiEd25519PublicKey.MAX_KEYS} public keys, inclusive`,
+        `Must have between ${MultiEd25519PublicKey.MIN_KEYS} and ` +
+          `${MultiEd25519PublicKey.MAX_KEYS} public keys, inclusive`,
       );
     }
 
@@ -71,6 +71,50 @@ export class MultiEd25519PublicKey extends PublicKey {
     this.threshold = threshold;
   }
 
+  // region AccountPublicKey
+
+  verifySignature(args: VerifySignatureArgs): boolean {
+    const { message, signature } = args;
+    if (!(signature instanceof MultiEd25519Signature)) {
+      return false;
+    }
+
+    const indices: number[] = [];
+    for (let i = 0; i < 4; i += 1) {
+      for (let j = 0; j < 8; j += 1) {
+        // eslint-disable-next-line no-bitwise
+        const bitIsSet = (signature.bitmap[i] & (1 << (7 - j))) !== 0;
+        if (bitIsSet) {
+          const index = i * 8 + j;
+          indices.push(index);
+        }
+      }
+    }
+
+    if (indices.length !== signature.signatures.length) {
+      throw new Error("Bitmap and signatures length mismatch");
+    }
+
+    if (indices.length < this.threshold) {
+      throw new Error("Not enough signatures");
+    }
+
+    for (let i = 0; i < indices.length; i += 1) {
+      const publicKey = this.publicKeys[indices[i]];
+      if (!publicKey.verifySignature({ message, signature: signature.signatures[i] })) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  authKey(): AuthenticationKey {
+    return AuthenticationKey.fromSchemeAndBytes({
+      scheme: AuthenticationKeyScheme.MultiEd25519,
+      input: this.toUint8Array(),
+    });
+  }
+
   /**
    * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold
    */
@@ -85,14 +129,9 @@ export class MultiEd25519PublicKey extends PublicKey {
     return bytes;
   }
 
-  toString(): string {
-    return Hex.fromHexInput(this.toUint8Array()).toString();
-  }
+  // endregion
 
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args: { message: HexInput; signature: MultiEd25519Signature }): boolean {
-    throw new Error("TODO - Method not implemented.");
-  }
+  // region Serializable
 
   serialize(serializer: Serializer): void {
     serializer.serializeBytes(this.toUint8Array());
@@ -110,6 +149,8 @@ export class MultiEd25519PublicKey extends PublicKey {
     }
     return new MultiEd25519PublicKey({ publicKeys: keys, threshold });
   }
+
+  // endregion
 }
 
 /**
@@ -146,26 +187,33 @@ export class MultiEd25519Signature extends Signature {
    *
    * @param args.signatures A list of signatures
    * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth
-   * signature should be provided in `signatures`. Bits are read from left to right
+   * signature should be provided in `signatures`. Bits are read from left to right.
+   * Alternatively, you can specify an array of bitmap positions.
+   * Valid position should range between 0 and 31.
+   * @see MultiEd25519Signature.createBitmap
    */
-  constructor(args: { signatures: Ed25519Signature[]; bitmap: Uint8Array }) {
+  constructor(args: { signatures: Ed25519Signature[]; bitmap: Uint8Array | number[] }) {
     super();
-
     const { signatures, bitmap } = args;
-    if (bitmap.length !== MultiEd25519Signature.BITMAP_LEN) {
-      throw new Error(`"bitmap" length should be ${MultiEd25519Signature.BITMAP_LEN}`);
-    }
 
     if (signatures.length > MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {
       throw new Error(
         `The number of signatures cannot be greater than ${MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED}`,
       );
     }
-
     this.signatures = signatures;
-    this.bitmap = bitmap;
+
+    if (!(bitmap instanceof Uint8Array)) {
+      this.bitmap = MultiEd25519Signature.createBitmap({ bits: bitmap });
+    } else if (bitmap.length !== MultiEd25519Signature.BITMAP_LEN) {
+      throw new Error(`"bitmap" length should be ${MultiEd25519Signature.BITMAP_LEN}`);
+    } else {
+      this.bitmap = bitmap;
+    }
   }
 
+  // region AccountSignature
+
   /**
    * Converts a MultiSignature into Uint8Array (bytes) with `bytes = s1_bytes | ... | sn_bytes | bitmap`
    */
@@ -180,10 +228,29 @@ export class MultiEd25519Signature extends Signature {
     return bytes;
   }
 
-  toString(): string {
-    return Hex.fromHexInput(this.toUint8Array()).toString();
+  // endregion
+
+  // region Serializable
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.toUint8Array());
   }
 
+  static deserialize(deserializer: Deserializer): MultiEd25519Signature {
+    const bytes = deserializer.deserializeBytes();
+    const bitmap = bytes.subarray(bytes.length - 4);
+
+    const signatures: Ed25519Signature[] = [];
+
+    for (let i = 0; i < bytes.length - bitmap.length; i += Ed25519Signature.LENGTH) {
+      const begin = i;
+      signatures.push(new Ed25519Signature(bytes.subarray(begin, begin + Ed25519Signature.LENGTH)));
+    }
+    return new MultiEd25519Signature({ signatures, bitmap });
+  }
+
+  // endregion
+
   /**
    * Helper method to create a bitmap out of the specified bit positions
    * @param args.bits The bitmap positions that should be set. A position starts at index 0.
@@ -208,7 +275,7 @@ export class MultiEd25519Signature extends Signature {
     // Check if duplicates exist in bits
     const dupCheckSet = new Set();
 
-    bits.forEach((bit: number) => {
+    bits.forEach((bit: number, index) => {
       if (bit >= MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {
         throw new Error(`Cannot have a signature larger than ${MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED - 1}.`);
       }
@@ -217,6 +284,10 @@ export class MultiEd25519Signature extends Signature {
         throw new Error("Duplicate bits detected.");
       }
 
+      if (index > 0 && bit <= bits[index - 1]) {
+        throw new Error("The bits need to be sorted in ascending order.");
+      }
+
       dupCheckSet.add(bit);
 
       const byteOffset = Math.floor(bit / 8);
@@ -231,21 +302,4 @@ export class MultiEd25519Signature extends Signature {
 
     return bitmap;
   }
-
-  serialize(serializer: Serializer): void {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-
-  static deserialize(deserializer: Deserializer): MultiEd25519Signature {
-    const bytes = deserializer.deserializeBytes();
-    const bitmap = bytes.subarray(bytes.length - 4);
-
-    const signatures: Ed25519Signature[] = [];
-
-    for (let i = 0; i < bytes.length - bitmap.length; i += Ed25519Signature.LENGTH) {
-      const begin = i;
-      signatures.push(new Ed25519Signature(bytes.subarray(begin, begin + Ed25519Signature.LENGTH)));
-    }
-    return new MultiEd25519Signature({ signatures, bitmap });
-  }
 }