@aptos-labs/ts-sdk 1.7.0 → 1.9.0

package/src/core/crypto/secp256k1.ts

@@ -4,11 +4,13 @@
 import { sha3_256 } from "@noble/hashes/sha3";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { HDKey } from "@scure/bip32";
-import { PrivateKey, PublicKey, Signature } from "./asymmetricCrypto";
-import { Deserializer, Serializer } from "../../bcs";
+import { Serializable, Deserializer, Serializer } from "../../bcs";
 import { Hex } from "../hex";
 import { HexInput } from "../../types";
 import { isValidBIP44Path, mnemonicToSeed } from "./hdKey";
+import { PrivateKey } from "./privateKey";
+import { PublicKey, VerifySignatureArgs } from "./publicKey";
+import { Signature } from "./signature";
 
 /**
  * Represents the Secp256k1 ecdsa public key
@@ -37,38 +39,27 @@ export class Secp256k1PublicKey extends PublicKey {
     this.key = hex;
   }
 
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
+  // region PublicKey
+
+  verifySignature(args: VerifySignatureArgs): boolean {
+    const { message, signature } = args;
+    if (!(signature instanceof Secp256k1Signature)) {
+      return false;
+    }
+
+    const messageBytes = Hex.fromHexInput(message).toUint8Array();
+    const messageSha3Bytes = sha3_256(messageBytes);
+    const signatureBytes = signature.toUint8Array();
+    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array());
+  }
+
   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();
-  }
+  // endregion
 
-  /**
-   * 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());
-  }
+  // region Serializable
 
   serialize(serializer: Serializer): void {
     serializer.serializeBytes(this.key.toUint8Array());
@@ -79,11 +70,12 @@ export class Secp256k1PublicKey extends PublicKey {
     return new Secp256k1PublicKey(bytes);
   }
 
-  static load(deserializer: Deserializer): Secp256k1PublicKey {
-    const bytes = deserializer.deserializeBytes();
-    return new Secp256k1PublicKey(bytes);
-  }
+  // endregion
 
+  /**
+   * @deprecated use `instanceof Secp256k1PublicKey` instead
+   * @param publicKey
+   */
   static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
     return publicKey instanceof Secp256k1PublicKey;
   }
@@ -92,7 +84,7 @@ export class Secp256k1PublicKey extends PublicKey {
 /**
  * A Secp256k1 ecdsa private key
  */
-export class Secp256k1PrivateKey extends PrivateKey {
+export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   /**
    * Length of Secp256k1 ecdsa private key
    */
@@ -104,6 +96,8 @@ export class Secp256k1PrivateKey extends PrivateKey {
    */
   private readonly key: Hex;
 
+  // region Constructors
+
   /**
    * Create a new PrivateKey instance from a Uint8Array or String.
    *
@@ -120,46 +114,6 @@ export class Secp256k1PrivateKey extends PrivateKey {
     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.
    *
@@ -170,16 +124,6 @@ export class Secp256k1PrivateKey extends PrivateKey {
     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);
-  }
-
   /**
    * Derives a private key from a mnemonic seed phrase.
    *
@@ -214,13 +158,76 @@ export class Secp256k1PrivateKey extends PrivateKey {
     return new Secp256k1PrivateKey(privateKey);
   }
 
+  // endregion
+
+  // region PrivateKey
+
+  /**
+   * Sign the given message with the private key.
+   *
+   * @param message in HexInput format
+   * @returns Signature
+   */
+  sign(message: HexInput): Secp256k1Signature {
+    const messageBytes = Hex.fromHexInput(message);
+    const messageHashBytes = sha3_256(messageBytes.toUint8Array());
+    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array());
+    return new Secp256k1Signature(signature.toCompactRawBytes());
+  }
+
+  /**
+   * Derive the Secp256k1PublicKey from this private key.
+   *
+   * @returns Secp256k1PublicKey
+   */
+  publicKey(): Secp256k1PublicKey {
+    const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);
+    return new Secp256k1PublicKey(bytes);
+  }
+
+  /**
+   * 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();
+  }
+
+  // endregion
+
+  // region Serializable
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.toUint8Array());
+  }
+
+  static deserialize(deserializer: Deserializer): Secp256k1PrivateKey {
+    const bytes = deserializer.deserializeBytes();
+    return new Secp256k1PrivateKey(bytes);
+  }
+
+  // endregion
+
+  /**
+   * @deprecated use `instanceof Secp256k1PrivateKey` instead
+   */
   static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey {
     return privateKey instanceof Secp256k1PrivateKey;
   }
 }
 
 /**
- * A signature of a message signed using an Secp256k1 ecdsa private key
+ * A signature of a message signed using a Secp256k1 ecdsa private key
  */
 export class Secp256k1Signature extends Signature {
   /**
@@ -234,6 +241,8 @@ export class Secp256k1Signature extends Signature {
    */
   private readonly data: Hex;
 
+  // region Constructors
+
   /**
    * Create a new Signature instance from a Uint8Array or String.
    *
@@ -241,31 +250,26 @@ export class Secp256k1Signature extends Signature {
    */
   constructor(hexInput: HexInput) {
     super();
-
-    const hex = Hex.fromHexInput(hexInput);
-    if (hex.toUint8Array().length !== Secp256k1Signature.LENGTH) {
-      throw new Error(`Signature length should be ${Secp256k1Signature.LENGTH}, recieved ${hex.toUint8Array().length}`);
+    const data = Hex.fromHexInput(hexInput);
+    if (data.toUint8Array().length !== Secp256k1Signature.LENGTH) {
+      throw new Error(
+        `Signature length should be ${Secp256k1Signature.LENGTH}, received ${data.toUint8Array().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());
@@ -276,12 +280,5 @@ export class Secp256k1Signature extends Signature {
     return new Secp256k1Signature(hex);
   }
 
-  static load(deserializer: Deserializer): Secp256k1Signature {
-    const bytes = deserializer.deserializeBytes();
-    return new Secp256k1Signature(bytes);
-  }
-
-  static isSignature(signature: Signature): signature is Secp256k1Signature {
-    return signature instanceof Secp256k1Signature;
-  }
+  // endregion
 }

package/src/core/crypto/signature.ts

@@ -0,0 +1,46 @@
+import { Serializable } from "../../bcs";
+import { Hex } from "../hex";
+
+/**
+ * An abstract representation of a crypto signature,
+ * associated to a specific signature scheme e.g. Ed25519 or Secp256k1
+ *
+ * This is the product of signing a message directly from a PrivateKey
+ * and can be verified against a CryptoPublicKey.
+ */
+export abstract class Signature extends Serializable {
+  /**
+   * Get the raw signature bytes
+   */
+  abstract toUint8Array(): Uint8Array;
+
+  /**
+   * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
+   */
+  toString(): string {
+    const bytes = this.toUint8Array();
+    return Hex.fromHexInput(bytes).toString();
+  }
+}
+
+/**
+ * An abstract representation of an account signature,
+ * associated to a specific authentication scheme e.g. Ed25519 or SingleKey
+ *
+ * This is the product of signing a message through an account,
+ * and can be verified against an AccountPublicKey.
+ */
+// export abstract class AccountSignature extends Serializable {
+//   /**
+//    * Get the raw signature bytes
+//    */
+//   abstract toUint8Array(): Uint8Array;
+//
+//   /**
+//    * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
+//    */
+//   toString(): string {
+//     const bytes = this.toUint8Array();
+//     return Hex.fromHexInput(bytes).toString();
+//   }
+// }

package/src/core/crypto/singleKey.ts

@@ -0,0 +1,180 @@
+import { Deserializer, Serializer } from "../../bcs";
+import { AnyPublicKeyVariant, AnySignatureVariant, SigningScheme as AuthenticationKeyScheme } from "../../types";
+import { AuthenticationKey } from "../authenticationKey";
+import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
+import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
+import { Secp256k1PublicKey, Secp256k1Signature } from "./secp256k1";
+import { Signature } from "./signature";
+
+/**
+ * Represents any public key supported by Aptos.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
+ *
+ * Any unified authentication key is represented in the SDK as `AnyPublicKey`.
+ */
+export class AnyPublicKey extends AccountPublicKey {
+  /**
+   * Reference to the inner public key
+   */
+  public readonly publicKey: PublicKey;
+
+  /**
+   * Index of the underlying enum variant
+   */
+  public readonly variant: AnyPublicKeyVariant;
+
+  // region Constructors
+
+  constructor(publicKey: PublicKey) {
+    super();
+    this.publicKey = publicKey;
+    if (publicKey instanceof Ed25519PublicKey) {
+      this.variant = AnyPublicKeyVariant.Ed25519;
+    } else if (publicKey instanceof Secp256k1PublicKey) {
+      this.variant = AnyPublicKeyVariant.Secp256k1;
+    } else {
+      throw new Error("Unsupported public key type");
+    }
+  }
+
+  // endregion
+
+  // region AccountPublicKey
+
+  verifySignature(args: VerifySignatureArgs): boolean {
+    const { message, signature } = args;
+    if (!(signature instanceof AnySignature)) {
+      return false;
+    }
+
+    return this.publicKey.verifySignature({
+      message,
+      signature: signature.signature,
+    });
+  }
+
+  authKey(): AuthenticationKey {
+    return AuthenticationKey.fromSchemeAndBytes({
+      scheme: AuthenticationKeyScheme.SingleKey,
+      input: this.toUint8Array(),
+    });
+  }
+
+  toUint8Array() {
+    return this.bcsToBytes();
+  }
+
+  // endregion
+
+  // region Serializable
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(this.variant);
+    this.publicKey.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): AnyPublicKey {
+    const variantIndex = deserializer.deserializeUleb128AsU32();
+    let publicKey: PublicKey;
+    switch (variantIndex) {
+      case AnyPublicKeyVariant.Ed25519:
+        publicKey = Ed25519PublicKey.deserialize(deserializer);
+        break;
+      case AnyPublicKeyVariant.Secp256k1:
+        publicKey = Secp256k1PublicKey.deserialize(deserializer);
+        break;
+      default:
+        throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
+    }
+    return new AnyPublicKey(publicKey);
+  }
+
+  // endregion
+
+  /**
+   * @deprecated use `instanceof AnyPublicKey` instead.
+   */
+  static isPublicKey(publicKey: AccountPublicKey): publicKey is AnyPublicKey {
+    return publicKey instanceof AnyPublicKey;
+  }
+
+  /**
+   * @deprecated use `publicKey instanceof Ed25519PublicKey` instead.
+   */
+  isEd25519(): boolean {
+    return this.publicKey instanceof Ed25519PublicKey;
+  }
+
+  /**
+   * @deprecated use `publicKey instanceof Secp256k1PublicKey` instead.
+   */
+  isSecp256k1PublicKey(): boolean {
+    return this.publicKey instanceof Secp256k1PublicKey;
+  }
+}
+
+/**
+ * Instance of signature that uses the SingleKey authentication scheme.
+ * This signature can only be generated by a `SingleKeySigner`, since it uses the
+ * same authentication scheme.
+ */
+export class AnySignature extends Signature {
+  public readonly signature: Signature;
+
+  /**
+   * Index of the underlying enum variant
+   */
+  private readonly variant: AnySignatureVariant;
+
+  // region Constructors
+
+  constructor(signature: Signature) {
+    super();
+    this.signature = signature;
+
+    if (signature instanceof Ed25519Signature) {
+      this.variant = AnySignatureVariant.Ed25519;
+    } else if (signature instanceof Secp256k1Signature) {
+      this.variant = AnySignatureVariant.Secp256k1;
+    } else {
+      throw new Error("Unsupported signature type");
+    }
+  }
+
+  // endregion
+
+  // region AccountSignature
+
+  toUint8Array() {
+    return this.bcsToBytes();
+  }
+
+  // endregion
+
+  // region Serializable
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(this.variant);
+    this.signature.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): AnySignature {
+    const variantIndex = deserializer.deserializeUleb128AsU32();
+    let signature: Signature;
+    switch (variantIndex) {
+      case AnySignatureVariant.Ed25519:
+        signature = Ed25519Signature.deserialize(deserializer);
+        break;
+      case AnySignatureVariant.Secp256k1:
+        signature = Secp256k1Signature.deserialize(deserializer);
+        break;
+      default:
+        throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
+    }
+    return new AnySignature(signature);
+  }
+
+  // endregion
+}

package/src/internal/account.ts

@@ -12,7 +12,7 @@ import { AptosConfig } from "../api/aptosConfig";
 import { AptosApiError, getAptosFullNode, paginateWithCursor } from "../client";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { Account } from "../core/account";
-import { PrivateKey } from "../core/crypto/asymmetricCrypto";
+import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
 import { getTableItem, queryIndexer } from "./general";
 import {
   AccountData,
@@ -54,7 +54,6 @@ import {
 } from "../types/generated/queries";
 import { memoizeAsync } from "../utils/memoize";
 import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey } from "../core";
-import { AnyPublicKey } from "../core/crypto/anyPublicKey";
 import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 
 export async function getInfo(args: {
@@ -549,7 +548,10 @@ export async function deriveAccountFromPrivateKey(args: {
       return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: false });
     }
     // lookup legacy ed25519
-    const legacyAuthKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.Ed25519 });
+    const legacyAuthKey = AuthenticationKey.fromPublicKeyAndScheme({
+      publicKey: publicKey.publicKey as Ed25519PublicKey,
+      scheme: SigningScheme.Ed25519,
+    });
     const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });
     if (isLegacyEd25519) {
       const address = legacyAuthKey.derivedAddress();

package/src/internal/digitalAsset.ts

@@ -302,6 +302,32 @@ export async function getCollectionData(args: {
   return data.current_collections_v2[0];
 }
 
+export async function getCollectionDataByCollectionId(args: {
+  aptosConfig: AptosConfig;
+  collectionId: AccountAddressInput;
+}): Promise<GetCollectionDataResponse> {
+  const { aptosConfig, collectionId } = args;
+  const address = AccountAddress.from(collectionId);
+
+  const whereCondition: any = {
+    collection_id: { _eq: address.toStringLong() },
+  };
+
+  const graphqlQuery = {
+    query: GetCollectionData,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+  const data = await queryIndexer<GetCollectionDataQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getCollectionData",
+  });
+
+  return data.current_collections_v2[0];
+}
+
 export async function getCollectionId(args: {
   aptosConfig: AptosConfig;
   creatorAddress: AccountAddressInput;

package/src/internal/event.ts

@@ -13,9 +13,39 @@ import { AccountAddress, AccountAddressInput } from "../core";
 import { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructId, OrderByArg, WhereArg } from "../types";
 import { GetEventsQuery } from "../types/generated/operations";
 import { GetEvents } from "../types/generated/queries";
-import { EventsBoolExp } from "../types/generated/types";
+import { EventsBoolExp, InputMaybe } from "../types/generated/types";
 import { queryIndexer } from "./general";
 
+const MAX_EVENT_TYPE_LENGTH = 300;
+const checkEventTypeLength = (eventType?: InputMaybe<string>) => {
+  if (eventType && eventType.length > MAX_EVENT_TYPE_LENGTH) {
+    throw new Error(`Event type length exceeds the maximum length of ${MAX_EVENT_TYPE_LENGTH}`);
+  }
+};
+
+export async function getModuleEventsByEventType(args: {
+  aptosConfig: AptosConfig;
+  eventType: MoveStructId;
+  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
+}): Promise<GetEventsResponse> {
+  const { aptosConfig, eventType, options } = args;
+
+  const whereCondition: EventsBoolExp = {
+    account_address: { _eq: "0x0000000000000000000000000000000000000000000000000000000000000000" },
+    creation_number: { _eq: "0" },
+    sequence_number: { _eq: "0" },
+    indexed_type: { _eq: eventType },
+  };
+
+  const customOptions = {
+    where: whereCondition,
+    pagination: options,
+    orderBy: options?.orderBy,
+  };
+
+  return getEvents({ aptosConfig, options: customOptions });
+}
+
 export async function getAccountEventsByCreationNumber(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
@@ -67,6 +97,8 @@ export async function getEvents(args: {
   options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;
 }): Promise<GetEventsResponse> {
   const { aptosConfig, options } = args;
+  // eslint-disable-next-line no-underscore-dangle
+  checkEventTypeLength(options?.where?.indexed_type?._eq);
 
   const graphqlQuery = {
     query: GetEvents,

package/src/internal/queries/currentTokenOwnershipFieldsFragment.graphql

@@ -25,6 +25,7 @@ fragment CurrentTokenOwnershipFields on current_token_ownerships_v2 {
     token_properties
     token_standard
     token_uri
+    decimals
     current_collection {
       collection_id
       collection_name

package/src/internal/queries/getTokenData.graphql

@@ -18,6 +18,7 @@ query getTokenData(
     token_properties
     token_standard
     token_uri
+    decimals
     current_collection {
       collection_id
       collection_name

package/src/transactions/authenticator/account.ts

@@ -4,8 +4,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 
 import { Serializer, Deserializer, Serializable } from "../../bcs";
-import { AnyPublicKey } from "../../core/crypto/anyPublicKey";
-import { AnySignature } from "../../core/crypto/anySignature";
+import { AnyPublicKey, AnySignature } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
 import { MultiKey } from "../../core/crypto/multiKey";

package/src/transactions/instances/rotationProofChallenge.ts

@@ -4,7 +4,7 @@
 import { Serializer, Serializable } from "../../bcs/serializer";
 import { AccountAddress } from "../../core/accountAddress";
 import { AnyNumber } from "../../types";
-import { PublicKey } from "../../core/crypto/asymmetricCrypto";
+import { PublicKey } from "../../core/crypto";
 import { MoveString, MoveVector, U64, U8 } from "../../bcs";
 
 /**