@aptos-labs/ts-sdk 1.7.0 → 1.9.0

package/src/core/account/SingleKeyAccount.ts

@@ -0,0 +1,120 @@
+import { AccountAuthenticatorSingleKey } from "../../transactions/authenticator/account";
+import { type HexInput, SigningScheme, SigningSchemeInput } from "../../types";
+import { AccountAddress, AccountAddressInput } from "../accountAddress";
+import { AnyPublicKey, AnySignature, Ed25519PrivateKey, PrivateKey, Secp256k1PrivateKey } from "../crypto";
+import type { Account } from "./Account";
+
+export interface SingleKeySignerConstructorArgs {
+  privateKey: PrivateKey;
+  address?: AccountAddressInput;
+}
+
+export interface SingleKeySignerGenerateArgs {
+  scheme?: SigningSchemeInput;
+}
+
+export type SingleKeySignerFromDerivationPathArgs = SingleKeySignerGenerateArgs & {
+  path: string;
+  mnemonic: string;
+};
+
+export interface VerifySingleKeySignatureArgs {
+  message: HexInput;
+  signature: AnySignature;
+}
+
+/**
+ * Signer implementation for the SingleKey authentication scheme.
+ * This extends a SingleKeyAccount by adding signing capabilities through a valid private key.
+ * Currently, the only supported signature schemes are Ed25519 and Secp256k1.
+ *
+ * Note: Generating a signer instance does not create the account on-chain.
+ */
+export class SingleKeyAccount implements Account {
+  /**
+   * Private key associated with the account
+   */
+  readonly privateKey: PrivateKey;
+
+  readonly publicKey: AnyPublicKey;
+
+  readonly accountAddress: AccountAddress;
+
+  readonly signingScheme = SigningScheme.SingleKey;
+
+  // region Constructors
+
+  constructor(args: SingleKeySignerConstructorArgs) {
+    const { privateKey, address } = args;
+    this.privateKey = privateKey;
+    this.publicKey = new AnyPublicKey(privateKey.publicKey());
+    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
+  }
+
+  /**
+   * Derives an account from a randomly generated private key.
+   * Default generation is using an Ed25519 key
+   * @returns Account with the given signature scheme
+   */
+  static generate(args: SingleKeySignerGenerateArgs = {}) {
+    const { scheme = SigningSchemeInput.Ed25519 } = args;
+    let privateKey: PrivateKey;
+    switch (scheme) {
+      case SigningSchemeInput.Ed25519:
+        privateKey = Ed25519PrivateKey.generate();
+        break;
+      case SigningSchemeInput.Secp256k1Ecdsa:
+        privateKey = Secp256k1PrivateKey.generate();
+        break;
+      default:
+        throw new Error(`Unsupported signature scheme ${scheme}`);
+    }
+    return new SingleKeyAccount({ privateKey });
+  }
+
+  /**
+   * Derives an account with bip44 path and mnemonics,
+   * Default to using an Ed25519 signature scheme.
+   *
+   * @param args.scheme The signature scheme to derive the private key with
+   * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
+   * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
+   * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+   * @param args.mnemonic the mnemonic seed phrase of the account
+   */
+  static fromDerivationPath(args: SingleKeySignerFromDerivationPathArgs) {
+    const { scheme = SigningSchemeInput.Ed25519, path, mnemonic } = args;
+    let privateKey: PrivateKey;
+    switch (scheme) {
+      case SigningSchemeInput.Ed25519:
+        privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);
+        break;
+      case SigningSchemeInput.Secp256k1Ecdsa:
+        privateKey = Secp256k1PrivateKey.fromDerivationPath(path, mnemonic);
+        break;
+      default:
+        throw new Error(`Unsupported signature scheme ${scheme}`);
+    }
+    return new SingleKeyAccount({ privateKey });
+  }
+
+  // endregion
+
+  // region Account
+
+  verifySignature(args: VerifySingleKeySignatureArgs): boolean {
+    return this.publicKey.verifySignature(args);
+  }
+
+  signWithAuthenticator(message: HexInput) {
+    const innerSignature = this.privateKey.sign(message);
+    const signature = new AnySignature(innerSignature);
+    return new AccountAuthenticatorSingleKey(this.publicKey, signature);
+  }
+
+  sign(message: HexInput) {
+    return this.signWithAuthenticator(message).signature;
+  }
+
+  // endregion
+}

package/src/core/account/index.ts

@@ -0,0 +1,3 @@
+export * from "./Ed25519Account";
+export * from "./Account";
+export * from "./SingleKeyAccount";

package/src/core/authenticationKey.ts

@@ -3,13 +3,9 @@
 
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { AccountAddress } from "./accountAddress";
-import { PublicKey } from "./crypto/asymmetricCrypto";
-import { Ed25519PublicKey } from "./crypto/ed25519";
-import { MultiEd25519PublicKey } from "./crypto/multiEd25519";
+import type { AccountPublicKey } from "./crypto";
 import { Hex } from "./hex";
-import { AuthenticationKeyScheme, HexInput, SigningScheme } from "../types";
-import { AnyPublicKey } from "./crypto/anyPublicKey";
-import { MultiKey } from "./crypto/multiKey";
+import { AuthenticationKeyScheme, HexInput } from "../types";
 import { Serializable, Serializer } from "../bcs/serializer";
 import { Deserializer } from "../bcs/deserializer";
 
@@ -65,41 +61,27 @@ export class AuthenticationKey extends Serializable {
     return this.data.toUint8Array();
   }
 
+  static fromSchemeAndBytes(args: { scheme: AuthenticationKeyScheme; input: HexInput }): AuthenticationKey {
+    const { scheme, input } = args;
+    const inputBytes = Hex.fromHexInput(input).toUint8Array();
+    const hashInput = new Uint8Array([...inputBytes, scheme]);
+    const hash = sha3Hash.create();
+    hash.update(hashInput);
+    const hashDigest = hash.digest();
+    return new AuthenticationKey({ data: hashDigest });
+  }
+
   /**
+   * @deprecated Use `fromPublicKey` instead
    * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.
    *
    * This facilitates targeting a specific scheme for deriving an authentication key from a public key.
    *
    * @param args - the public key and scheme to use for the derivation
    */
-  public static fromPublicKeyAndScheme(args: { publicKey: PublicKey; scheme: AuthenticationKeyScheme }) {
-    const { publicKey, scheme } = args;
-    let authKeyBytes: Uint8Array;
-
-    switch (scheme) {
-      case SigningScheme.MultiKey:
-      case SigningScheme.SingleKey: {
-        const singleKeyBytes = publicKey.bcsToBytes();
-        authKeyBytes = new Uint8Array([...singleKeyBytes, scheme]);
-        break;
-      }
-
-      case SigningScheme.Ed25519:
-      case SigningScheme.MultiEd25519: {
-        const ed25519PublicKeyBytes = publicKey.toUint8Array();
-        const inputBytes = Hex.fromHexInput(ed25519PublicKeyBytes).toUint8Array();
-        authKeyBytes = new Uint8Array([...inputBytes, scheme]);
-        break;
-      }
-
-      default:
-        throw new Error(`Scheme ${scheme} is not supported`);
-    }
-
-    const hash = sha3Hash.create();
-    hash.update(authKeyBytes);
-    const hashDigest = hash.digest();
-    return new AuthenticationKey({ data: hashDigest });
+  public static fromPublicKeyAndScheme(args: { publicKey: AccountPublicKey; scheme: AuthenticationKeyScheme }) {
+    const { publicKey } = args;
+    return publicKey.authKey();
   }
 
   /**
@@ -109,25 +91,9 @@ export class AuthenticationKey extends Serializable {
    * @param args.publicKey
    * @returns AuthenticationKey
    */
-  static fromPublicKey(args: { publicKey: PublicKey }): AuthenticationKey {
+  static fromPublicKey(args: { publicKey: AccountPublicKey }): AuthenticationKey {
     const { publicKey } = args;
-
-    let scheme: number;
-    if (publicKey instanceof Ed25519PublicKey) {
-      // for legacy support
-      scheme = SigningScheme.Ed25519.valueOf();
-    } else if (publicKey instanceof MultiEd25519PublicKey) {
-      // for legacy support
-      scheme = SigningScheme.MultiEd25519.valueOf();
-    } else if (publicKey instanceof AnyPublicKey) {
-      scheme = SigningScheme.SingleKey.valueOf();
-    } else if (publicKey instanceof MultiKey) {
-      scheme = SigningScheme.MultiKey.valueOf();
-    } else {
-      throw new Error("No supported authentication scheme for public key");
-    }
-
-    return AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme });
+    return publicKey.authKey();
   }
 
   /**

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";