@aptos-labs/ts-sdk 0.0.0

package/src/core/crypto/secp256k1.ts

@@ -0,0 +1,227 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { sha3_256 } from "@noble/hashes/sha3";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { PrivateKey, PublicKey, Signature } from "./asymmetricCrypto";
+import { Deserializer, Serializer } from "../../bcs";
+import { Hex } from "../hex";
+import { HexInput } from "../../types";
+
+/**
+ * Represents the Secp256k1 ecdsa public key
+ */
+export class Secp256k1PublicKey extends PublicKey {
+  // Secp256k1 ecdsa public keys contain a prefix indicating compression and two 32-byte coordinates.
+  static readonly LENGTH: number = 65;
+
+  // Hex value of the public key
+  private readonly key: Hex;
+
+  /**
+   * Create a new PublicKey instance from a Uint8Array or String.
+   *
+   * @param hexInput A HexInput (string or Uint8Array)
+   */
+  constructor(hexInput: HexInput) {
+    super();
+
+    const hex = Hex.fromHexInput(hexInput);
+    if (hex.toUint8Array().length !== Secp256k1PublicKey.LENGTH) {
+      throw new Error(`PublicKey length should be ${Secp256k1PublicKey.LENGTH}`);
+    }
+    this.key = hex;
+  }
+
+  /**
+   * Get the public key in bytes (Uint8Array).
+   *
+   * @returns Uint8Array representation of the public key
+   */
+  toUint8Array(): Uint8Array {
+    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();
+  }
+
+  /**
+   * Verifies a signed data with a public key
+   *
+   * @param args.message message
+   * @param args.signature The signature
+   * @returns true if the signature is valid
+   */
+  verifySignature(args: { message: HexInput; signature: Secp256k1Signature }): boolean {
+    const { message, signature } = args;
+    const msgHex = Hex.fromHexInput(message).toUint8Array();
+    const sha3Message = sha3_256(msgHex);
+    const rawSignature = signature.toUint8Array();
+    return secp256k1.verify(rawSignature, sha3Message, this.toUint8Array());
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.key.toUint8Array());
+  }
+
+  static deserialize(deserializer: Deserializer): Secp256k1PublicKey {
+    const bytes = deserializer.deserializeBytes();
+    return new Secp256k1PublicKey(bytes);
+  }
+}
+
+/**
+ * A Secp256k1 ecdsa private key
+ */
+export class Secp256k1PrivateKey extends PrivateKey {
+  /**
+   * Length of Secp256k1 ecdsa private key
+   */
+  static readonly LENGTH: number = 32;
+
+  /**
+   * The private key bytes
+   * @private
+   */
+  private readonly key: Hex;
+
+  /**
+   * Create a new PrivateKey instance from a Uint8Array or String.
+   *
+   * @param hexInput A HexInput (string or Uint8Array)
+   */
+  constructor(hexInput: HexInput) {
+    super();
+
+    const privateKeyHex = Hex.fromHexInput(hexInput);
+    if (privateKeyHex.toUint8Array().length !== Secp256k1PrivateKey.LENGTH) {
+      throw new Error(`PrivateKey length should be ${Secp256k1PrivateKey.LENGTH}`);
+    }
+
+    this.key = privateKeyHex;
+  }
+
+  /**
+   * Get the private key in bytes (Uint8Array).
+   *
+   * @returns
+   */
+  toUint8Array(): Uint8Array {
+    return this.key.toUint8Array();
+  }
+
+  /**
+   * Get the private key as a hex string with the 0x prefix.
+   *
+   * @returns string representation of the private key
+   */
+  toString(): string {
+    return this.key.toString();
+  }
+
+  /**
+   * Sign the given message with the private key.
+   *
+   * @param message in HexInput format
+   * @returns Signature
+   */
+  sign(message: HexInput): Secp256k1Signature {
+    const msgHex = Hex.fromHexInput(message);
+    const sha3Message = sha3_256(msgHex.toUint8Array());
+    const signature = secp256k1.sign(sha3Message, this.key.toUint8Array());
+    return new Secp256k1Signature(signature.toCompactRawBytes());
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.toUint8Array());
+  }
+
+  static deserialize(deserializer: Deserializer): Secp256k1PrivateKey {
+    const bytes = deserializer.deserializeBytes();
+    return new Secp256k1PrivateKey(bytes);
+  }
+
+  /**
+   * Generate a new random private key.
+   *
+   * @returns Secp256k1PrivateKey
+   */
+  static generate(): Secp256k1PrivateKey {
+    const hexInput = secp256k1.utils.randomPrivateKey();
+    return new Secp256k1PrivateKey(hexInput);
+  }
+
+  /**
+   * Derive the Secp256k1PublicKey from this private key.
+   *
+   * @returns Secp256k1PublicKey
+   */
+  publicKey(): Secp256k1PublicKey {
+    const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);
+    return new Secp256k1PublicKey(bytes);
+  }
+}
+
+/**
+ * A signature of a message signed using an Secp256k1 ecdsa private key
+ */
+export class Secp256k1Signature extends Signature {
+  /**
+   * Secp256k1 ecdsa signatures are 256-bit.
+   */
+  static readonly LENGTH = 64;
+
+  /**
+   * The signature bytes
+   * @private
+   */
+  private readonly data: Hex;
+
+  /**
+   * Create a new Signature instance from a Uint8Array or String.
+   *
+   * @param hexInput A HexInput (string or Uint8Array)
+   */
+  constructor(hexInput: HexInput) {
+    super();
+
+    const hex = Hex.fromHexInput(hexInput);
+    if (hex.toUint8Array().length !== Secp256k1Signature.LENGTH) {
+      throw new Error(`Signature length should be ${Secp256k1Signature.LENGTH}`);
+    }
+    this.data = hex;
+  }
+
+  /**
+   * Get the signature in bytes (Uint8Array).
+   *
+   * @returns Uint8Array representation of the 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();
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.data.toUint8Array());
+  }
+
+  static deserialize(deserializer: Deserializer): Secp256k1Signature {
+    const hex = deserializer.deserializeBytes();
+    return new Secp256k1Signature(hex);
+  }
+}

package/src/core/hex.ts

@@ -0,0 +1,177 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { ParsingError, ParsingResult } from "./common";
+import { HexInput } from "../types";
+
+/**
+ * This enum is used to explain why parsing might have failed.
+ */
+export enum HexInvalidReason {
+  TOO_SHORT = "too_short",
+  INVALID_LENGTH = "invalid_length",
+  INVALID_HEX_CHARS = "invalid_hex_chars",
+}
+
+/**
+ * NOTE: Do not use this class when working with account addresses, use AccountAddress.
+ *
+ * NOTE: When accepting hex data as input to a function, prefer to accept HexInput and
+ * then use the static helper methods of this class to convert it into the desired
+ * format. This enables the greatest flexibility for the developer.
+ *
+ * Hex is a helper class for working with hex data. Hex data, when represented as a
+ * string, generally looks like this, for example: 0xaabbcc, 45cd32, etc.
+ *
+ * You might use this class like this:
+ *
+ * ```ts
+ * getTransactionByHash(txnHash: HexInput): Promise<Transaction> {
+ *   const txnHashString = Hex.fromHexInput(txnHash).toString();
+ *   return await getTransactionByHashInner(txnHashString);
+ * }
+ * ```
+ *
+ * This call to `Hex.fromHexInput().toString()` converts the HexInput to a hex string
+ * with a leading 0x prefix, regardless of what the input format was.
+ *
+ * These are some other ways to chain the functions together:
+ * - `Hex.fromString({ hexInput: "0x1f" }).toUint8Array()`
+ * - `new Hex([1, 3]).toStringWithoutPrefix()`
+ */
+export class Hex {
+  private readonly data: Uint8Array;
+
+  /**
+   * Create a new Hex instance from a Uint8Array.
+   *
+   * @param data Uint8Array
+   */
+  constructor(data: Uint8Array) {
+    this.data = data;
+  }
+
+  // ===
+  // Methods for representing an instance of Hex as other types.
+  // ===
+
+  /**
+   * Get the inner hex data. The inner data is already a Uint8Array so no conversion
+   * is taking place here, it just returns the inner data.
+   *
+   * @returns Hex data as Uint8Array
+   */
+  toUint8Array(): Uint8Array {
+    return this.data;
+  }
+
+  /**
+   * Get the hex data as a string without the 0x prefix.
+   *
+   * @returns Hex string without 0x prefix
+   */
+  toStringWithoutPrefix(): string {
+    return bytesToHex(this.data);
+  }
+
+  /**
+   * Get the hex data as a string with the 0x prefix.
+   *
+   * @returns Hex string with 0x prefix
+   */
+  toString(): string {
+    return `0x${this.toStringWithoutPrefix()}`;
+  }
+
+  // ===
+  // Methods for creating an instance of Hex from other types.
+  // ===
+
+  /**
+   * Static method to convert a hex string to Hex
+   *
+   * @param str A hex string, with or without the 0x prefix
+   *
+   * @returns Hex
+   */
+  static fromString(str: string): Hex {
+    let input = str;
+
+    if (input.startsWith("0x")) {
+      input = input.slice(2);
+    }
+
+    if (input.length === 0) {
+      throw new ParsingError(
+        "Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.",
+        HexInvalidReason.TOO_SHORT,
+      );
+    }
+
+    if (input.length % 2 !== 0) {
+      throw new ParsingError("Hex string must be an even number of hex characters.", HexInvalidReason.INVALID_LENGTH);
+    }
+
+    try {
+      return new Hex(hexToBytes(input));
+    } catch (e) {
+      const error = e as Error;
+      throw new ParsingError(
+        `Hex string contains invalid hex characters: ${error.message}`,
+        HexInvalidReason.INVALID_HEX_CHARS,
+      );
+    }
+  }
+
+  /**
+   * Static method to convert an instance of HexInput to Hex
+   *
+   * @param hexInput A HexInput (string or Uint8Array)
+   *
+   * @returns Hex
+   */
+  static fromHexInput(hexInput: HexInput): Hex {
+    if (hexInput instanceof Uint8Array) return new Hex(hexInput);
+    return Hex.fromString(hexInput);
+  }
+
+  // ===
+  // Methods for checking validity.
+  // ===
+
+  /**
+   * Check if the string is valid hex.
+   *
+   * @param str A hex string representing byte data.
+   *
+   * @returns valid = true if the string is valid, false if not. If the string is not
+   * valid, invalidReason and invalidReasonMessage will be set explaining why it is
+   * invalid.
+   */
+  static isValid(str: string): ParsingResult<HexInvalidReason> {
+    try {
+      Hex.fromString(str);
+      return { valid: true };
+    } catch (e) {
+      const error = e as ParsingError<HexInvalidReason>;
+      return {
+        valid: false,
+        invalidReason: error.invalidReason,
+        invalidReasonMessage: error.message,
+      };
+    }
+  }
+
+  /**
+   * Return whether Hex instances are equal. Hex instances are considered equal if
+   * their underlying byte data is identical.
+   *
+   * @param other The Hex instance to compare to.
+   * @returns true if the Hex instances are equal, false if not.
+   */
+  equals(other: Hex): boolean {
+    if (this.data.length !== other.data.length) return false;
+    return this.data.every((value, index) => value === other.data[index]);
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,9 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./account";
+export * from "./accountAddress";
+export * from "./authenticationKey";
+export * from "./common";
+export * from "./crypto";
+export * from "./hex";

package/src/index.ts

@@ -0,0 +1,12 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./api";
+export * from "./bcs";
+export * from "./client";
+export * from "./core";
+export * from "./transactions/types";
+export * from "./transactions/typeTag/typeTag";
+export * from "./types";
+export * from "./utils/apiEndpoints";
+export * from "./utils/hdKey";