@aptos-labs/ts-sdk 1.36.0 → 1.37.1

package/src/core/crypto/multiEd25519.ts

@@ -1,12 +1,12 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+import { AptosConfig } from "../../api";
 import { Deserializer, Serializer } from "../../bcs";
-import { SigningScheme as AuthenticationKeyScheme } from "../../types";
+import { SigningScheme as AuthenticationKeyScheme, HexInput } from "../../types";
 import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
 import { AbstractMultiKey } from "./multiKey";
-import { VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
 
 /**
@@ -106,7 +106,7 @@ export class MultiEd25519PublicKey extends AbstractMultiKey {
    * @group Implementation
    * @category Serialization
    */
-  verifySignature(args: VerifySignatureArgs): boolean {
+  verifySignature(args: { message: HexInput; signature: Signature }): boolean {
     const { message, signature } = args;
     if (!(signature instanceof MultiEd25519Signature)) {
       return false;
@@ -141,6 +141,14 @@ export class MultiEd25519PublicKey extends AbstractMultiKey {
     return true;
   }
 
+  async verifySignatureAsync(args: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: Signature;
+  }): Promise<boolean> {
+    return this.verifySignature(args);
+  }
+
   /**
    * Generates an authentication key based on the current instance's byte representation.
    * This function is essential for creating a secure authentication key that can be used for various cryptographic operations.

package/src/core/crypto/multiKey.ts

@@ -1,10 +1,11 @@
-import { SigningScheme as AuthenticationKeyScheme } from "../../types";
+import { SigningScheme as AuthenticationKeyScheme, HexInput } from "../../types";
 import { Deserializer } from "../../bcs/deserializer";
 import { Serializer } from "../../bcs/serializer";
 import { AuthenticationKey } from "../authenticationKey";
-import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
+import { AccountPublicKey, PublicKey, VerifySignatureAsyncArgs } from "./publicKey";
 import { Signature } from "./signature";
 import { AnyPublicKey, AnySignature } from "./singleKey";
+import { AptosConfig } from "../../api";
 
 /**
  * Counts the number of set bits (1s) in a byte.
@@ -165,19 +166,74 @@ export class MultiKey extends AbstractMultiKey {
 
   // region AccountPublicKey
 
+  /**
+   * Verifies the provided signature against the given message.
+   * This function helps ensure the integrity and authenticity of the message by checking if the signature is valid.
+   *
+   * Note: This function will fail if a keyless signature is used.  Use `verifySignatureAsync` instead.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - The message that was signed.
+   * @param args.signature - The signature to verify.
+   * @group Implementation
+   * @category Serialization
+   */
+  verifySignature(args: { message: HexInput; signature: MultiKeySignature }): boolean {
+    const { message, signature } = args;
+    if (signature.signatures.length !== this.signaturesRequired) {
+      throw new Error("The number of signatures does not match the number of required signatures");
+    }
+    const signerIndices = signature.bitMapToSignerIndices();
+    for (let i = 0; i < signature.signatures.length; i += 1) {
+      const singleSignature = signature.signatures[i];
+      const publicKey = this.publicKeys[signerIndices[i]];
+      if (!publicKey.verifySignature({ message, signature: singleSignature })) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   /**
    * Verifies the provided signature against the given message.
    * This function helps ensure the integrity and authenticity of the message by checking if the signature is valid.
    *
    * @param args - The arguments for verifying the signature.
+   * @param args.aptosConfig - The Aptos configuration to use
    * @param args.message - The message that was signed.
    * @param args.signature - The signature to verify.
    * @group Implementation
    * @category Serialization
    */
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args: VerifySignatureArgs): boolean {
-    throw new Error("not implemented");
+  async verifySignatureAsync(args: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: Signature;
+    options?: { throwErrorWithReason?: boolean };
+  }): Promise<boolean> {
+    const { signature } = args;
+    try {
+      if (!(signature instanceof MultiKeySignature)) {
+        throw new Error("Signature is not a MultiKeySignature");
+      }
+      if (signature.signatures.length !== this.signaturesRequired) {
+        throw new Error("The number of signatures does not match the number of required signatures");
+      }
+      const signerIndices = signature.bitMapToSignerIndices();
+      for (let i = 0; i < signature.signatures.length; i += 1) {
+        const singleSignature = signature.signatures[i];
+        const publicKey = this.publicKeys[signerIndices[i]];
+        if (!(await publicKey.verifySignatureAsync({ ...args, signature: singleSignature }))) {
+          return false;
+        }
+      }
+      return true;
+    } catch (error) {
+      if (args.options?.throwErrorWithReason) {
+        throw error;
+      }
+      return false;
+    }
   }
 
   /**
@@ -380,6 +436,31 @@ export class MultiKeySignature extends Signature {
     return bitmap;
   }
 
+  /**
+   * Converts the bitmap to an array of signer indices.
+   *
+   * Example:
+   *
+   * bitmap: [0b10001000, 0b01000000, 0b00000000, 0b00000000]
+   * signerIndices: [0, 4, 9]
+   *
+   * @returns An array of signer indices.
+   * @group Implementation
+   * @category Serialization
+   */
+  bitMapToSignerIndices(): number[] {
+    const signerIndices: number[] = [];
+    for (let i = 0; i < this.bitmap.length; i += 1) {
+      const byte = this.bitmap[i];
+      for (let bit = 0; bit < 8; bit += 1) {
+        if ((byte & (128 >> bit)) !== 0) {
+          signerIndices.push(i * 8 + bit);
+        }
+      }
+    }
+    return signerIndices;
+  }
+
   // region Serializable
 
   serialize(serializer: Serializer): void {

package/src/core/crypto/publicKey.ts

@@ -1,3 +1,4 @@
+import { AptosConfig } from "../../api";
 import { Serializable } from "../../bcs";
 import { HexInput } from "../../types";
 import { AuthenticationKey } from "../authenticationKey";
@@ -17,6 +18,23 @@ export interface VerifySignatureArgs {
   signature: Signature;
 }
 
+/**
+ * Represents the arguments required to verify a digital signature asynchronously.
+ *
+ * The validity of certain types of signatures are dependent on network state.  This is the case for
+ * Keyless signatures which need to lookup the verification key and keyless configuration.
+ *
+ * @param aptosConfig - The Aptos configuration to use
+ * @param message - The original message that was signed.
+ * @param signature - The signature to be verified against the message.
+ * @group Implementation
+ * @category Serialization
+ */
+export type VerifySignatureAsyncArgs = VerifySignatureArgs & {
+  aptosConfig: AptosConfig;
+  options?: any;
+};
+
 /**
  * Represents an abstract public key.
  *
@@ -35,6 +53,16 @@ export abstract class PublicKey extends Serializable {
    */
   abstract verifySignature(args: VerifySignatureArgs): boolean;
 
+  /**
+   * Verifies signature with the public key and makes any network calls required to get state required to verify the signature.
+   * @param args.aptosConfig The Aptos configuration
+   * @param args.message The message that was signed
+   * @param args.signature The signature to verify
+   * @group Implementation
+   * @category Serialization
+   */
+  abstract verifySignatureAsync(args: VerifySignatureAsyncArgs): Promise<boolean>;
+
   /**
    * Get the raw public key bytes
    * @group Implementation

package/src/core/crypto/secp256k1.ts

@@ -9,9 +9,10 @@ import { Hex } from "../hex";
 import { HexInput, PrivateKeyVariants } from "../../types";
 import { isValidBIP44Path, mnemonicToSeed } from "./hdKey";
 import { PrivateKey } from "./privateKey";
-import { PublicKey, VerifySignatureArgs } from "./publicKey";
+import { PublicKey } from "./publicKey";
 import { Signature } from "./signature";
 import { convertSigningMessage } from "./utils";
+import { AptosConfig } from "../../api";
 
 /**
  * Represents a Secp256k1 ECDSA public key.
@@ -69,7 +70,7 @@ export class Secp256k1PublicKey extends PublicKey {
    * @group Implementation
    * @category Serialization
    */
-  verifySignature(args: VerifySignatureArgs): boolean {
+  verifySignature(args: { message: HexInput; signature: Secp256k1Signature }): boolean {
     const { message, signature } = args;
     const messageToVerify = convertSigningMessage(message);
     const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
@@ -78,6 +79,28 @@ export class Secp256k1PublicKey extends PublicKey {
     return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true });
   }
 
+  /**
+   * Note: Secp256k1Signatures can be verified syncronously.
+   *
+   * Verifies the provided signature against the given message.
+   * This function helps ensure the integrity and authenticity of the message by confirming that the signature is valid.
+   *
+   * @param args - The arguments for signature verification.
+   * @param args.aptosConfig - The configuration object for connecting to the Aptos network
+   * @param args.message - The message that was signed.
+   * @param args.signature - The signature to verify, which must be an instance of Secp256k1Signature.
+   * @returns A boolean indicating whether the signature is valid for the given message.
+   * @group Implementation
+   * @category Serialization
+   */
+  async verifySignatureAsync(args: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: Secp256k1Signature;
+  }): Promise<boolean> {
+    return this.verifySignature(args);
+  }
+
   /**
    * Get the data as a Uint8Array representation.
    *

package/src/core/crypto/singleKey.ts

@@ -1,12 +1,18 @@
 import { Deserializer, Serializer } from "../../bcs";
-import { AnyPublicKeyVariant, AnySignatureVariant, SigningScheme as AuthenticationKeyScheme } from "../../types";
+import {
+  AnyPublicKeyVariant,
+  AnySignatureVariant,
+  SigningScheme as AuthenticationKeyScheme,
+  HexInput,
+} from "../../types";
 import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
+import { AccountPublicKey, PublicKey } from "./publicKey";
 import { Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature } from "./secp256k1";
 import { KeylessPublicKey, KeylessSignature } from "./keyless";
 import { Signature } from "./signature";
 import { FederatedKeylessPublicKey } from "./federatedKeyless";
+import { AptosConfig } from "../../api";
 
 export type PrivateKeyInput = Ed25519PrivateKey | Secp256k1PrivateKey;
 
@@ -77,18 +83,47 @@ export class AnyPublicKey extends AccountPublicKey {
    * @group Implementation
    * @category Serialization
    */
-  verifySignature(args: VerifySignatureArgs): boolean {
+  verifySignature(args: { message: HexInput; signature: AnySignature }): boolean {
     const { message, signature } = args;
-    if (!AnySignature.isInstance(signature)) {
-      return false;
+    if (this.publicKey instanceof KeylessPublicKey) {
+      throw new Error("Use verifySignatureAsync to verify Keyless signatures");
     }
-
     return this.publicKey.verifySignature({
       message,
       signature: signature.signature,
     });
   }
 
+  /**
+   * Verifies the provided signature against the given message.
+   * This function helps ensure the integrity and authenticity of the message by confirming that the signature is valid.
+   *
+   * @param args - The arguments for signature verification.
+   * @param args.aptosConfig - The configuration object for connecting to the Aptos network
+   * @param args.message - The message that was signed.
+   * @param args.signature - The signature to verify, which must be an instance of AnySignature.
+   * @returns A boolean indicating whether the signature is valid for the given message.
+   * @group Implementation
+   * @category Serialization
+   */
+  async verifySignatureAsync(args: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: Signature;
+    options?: { throwErrorWithReason?: boolean };
+  }): Promise<boolean> {
+    if (!(args.signature instanceof AnySignature)) {
+      if (args.options?.throwErrorWithReason) {
+        throw new Error("Signature must be an instance of AnySignature");
+      }
+      return false;
+    }
+    return await this.publicKey.verifySignatureAsync({
+      ...args,
+      signature: args.signature.signature,
+    });
+  }
+
   /**
    * Generates an authentication key from the current instance's byte representation.
    * This function is essential for creating a unique identifier for authentication purposes.

package/src/errors/index.ts

@@ -7,6 +7,7 @@ export enum KeylessErrorCategory {
   EXTERNAL_API_ERROR,
   SESSION_EXPIRED,
   INVALID_STATE,
+  INVALID_SIGNATURE,
   UNKNOWN,
 }
 
@@ -79,6 +80,20 @@ export enum KeylessErrorType {
 
   FULL_NODE_OTHER,
 
+  SIGNATURE_TYPE_INVALID,
+
+  SIGNATURE_EXPIRED,
+
+  MAX_EXPIRY_HORIZON_EXCEEDED,
+
+  EPHEMERAL_SIGNATURE_VERIFICATION_FAILED,
+
+  TRAINING_WHEELS_SIGNATURE_MISSING,
+
+  TRAINING_WHEELS_SIGNATURE_VERIFICATION_FAILED,
+
+  PROOF_VERIFICATION_FAILED,
+
   UNKNOWN,
 }
 
@@ -213,6 +228,41 @@ const KeylessErrors: { [key in KeylessErrorType]: [string, KeylessErrorCategory,
     KeylessErrorCategory.API_ERROR,
     KeylessErrorResolutionTip.SERVER_ERROR,
   ],
+  [KeylessErrorType.SIGNATURE_TYPE_INVALID]: [
+    "The signature is not a valid Keyless signature.",
+    KeylessErrorCategory.INVALID_SIGNATURE,
+    KeylessErrorResolutionTip.JOIN_SUPPORT_GROUP,
+  ],
+  [KeylessErrorType.SIGNATURE_EXPIRED]: [
+    "The ephemeral key pair used to sign the message has expired.",
+    KeylessErrorCategory.INVALID_SIGNATURE,
+    KeylessErrorResolutionTip.REAUTHENTICATE,
+  ],
+  [KeylessErrorType.MAX_EXPIRY_HORIZON_EXCEEDED]: [
+    "The expiry horizon on the signature exceeds the maximum allowed value.",
+    KeylessErrorCategory.INVALID_SIGNATURE,
+    KeylessErrorResolutionTip.REAUTHENTICATE,
+  ],
+  [KeylessErrorType.EPHEMERAL_SIGNATURE_VERIFICATION_FAILED]: [
+    "Failed to verify the ephemeral signature with the ephemeral public key.",
+    KeylessErrorCategory.INVALID_SIGNATURE,
+    KeylessErrorResolutionTip.REAUTHENTICATE,
+  ],
+  [KeylessErrorType.TRAINING_WHEELS_SIGNATURE_MISSING]: [
+    "The training wheels signature is missing but is required by the Keyless configuration.",
+    KeylessErrorCategory.INVALID_SIGNATURE,
+    KeylessErrorResolutionTip.REAUTHENTICATE,
+  ],
+  [KeylessErrorType.TRAINING_WHEELS_SIGNATURE_VERIFICATION_FAILED]: [
+    "Failed to verify the training wheels signature with the training wheels public key.",
+    KeylessErrorCategory.INVALID_SIGNATURE,
+    KeylessErrorResolutionTip.REAUTHENTICATE,
+  ],
+  [KeylessErrorType.PROOF_VERIFICATION_FAILED]: [
+    "The proof verification failed.",
+    KeylessErrorCategory.INVALID_SIGNATURE,
+    KeylessErrorResolutionTip.REAUTHENTICATE,
+  ],
   [KeylessErrorType.UNKNOWN]: [
     "An unknown error has occurred.",
     KeylessErrorCategory.UNKNOWN,

package/src/internal/account.ts

@@ -9,9 +9,15 @@
  * @group Implementation
  */
 import { AptosConfig } from "../api/aptosConfig";
-import { getAptosFullNode, paginateWithCursor, paginateWithObfuscatedCursor } from "../client";
+import {
+  getAptosFullNode,
+  getPageWithObfuscatedCursor,
+  paginateWithCursor,
+  paginateWithObfuscatedCursor,
+} from "../client";
 import {
   AccountData,
+  CursorPaginationArgs,
   GetAccountCoinsDataResponse,
   GetAccountCollectionsWithOwnedTokenResponse,
   GetAccountOwnedTokensFromCollectionResponse,
@@ -32,7 +38,7 @@ import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { Account, Ed25519Account, MultiEd25519Account } from "../account";
 import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
 import { queryIndexer } from "./general";
-import { getModules as getModulesUtil, getModule as getModuleUtil, getInfo as getInfoUtil } from "./utils";
+import { getModule as getModuleUtil, getInfo as getInfoUtil } from "./utils";
 import {
   GetAccountCoinsCountQuery,
   GetAccountCoinsDataQuery,
@@ -93,9 +99,50 @@ export async function getInfo(args: {
 export async function getModules(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  options?: PaginationArgs & LedgerVersionArg;
+  options?: { limit?: number } & LedgerVersionArg;
 }): Promise<MoveModuleBytecode[]> {
-  return getModulesUtil(args);
+  const { aptosConfig, accountAddress, options } = args;
+  return paginateWithObfuscatedCursor<{}, MoveModuleBytecode[]>({
+    aptosConfig,
+    originMethod: "getModules",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,
+    params: {
+      ledger_version: options?.ledgerVersion,
+      limit: options?.limit ?? 1000,
+    },
+  });
+}
+
+/**
+ * Retrieves the modules associated with a specified account address.
+ *
+ * @param args - The arguments for retrieving modules.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos blockchain.
+ * @param args.accountAddress - The address of the account whose modules are to be retrieved.
+ * @param args.options - Optional parameters for pagination and ledger version.
+ * @param args.options.cursor - The starting point for pagination.  Note, this is obfuscated and is not an index.
+ * @param args.options.limit - The maximum number of modules to retrieve (default is 100).
+ * @param args.options.ledgerVersion - The specific ledger version to query.
+ * @group Implementation
+ */
+export async function getModulesPage(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  options?: CursorPaginationArgs & LedgerVersionArg;
+}): Promise<{ modules: MoveModuleBytecode[]; cursor: string | undefined }> {
+  const { aptosConfig, accountAddress, options } = args;
+  const { response, cursor } = await getPageWithObfuscatedCursor<{}, MoveModuleBytecode[]>({
+    aptosConfig,
+    originMethod: "getModulesPage",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,
+    params: {
+      ledger_version: options?.ledgerVersion,
+      cursor: options?.cursor,
+      limit: options?.limit ?? 100,
+    },
+  });
+
+  return { modules: response.data, cursor };
 }
 
 /**
@@ -153,7 +200,6 @@ export async function getTransactions(args: {
  * @param args.aptosConfig - The configuration settings for Aptos.
  * @param args.accountAddress - The address of the account to fetch resources for.
  * @param args.options - Optional pagination and ledger version parameters.
- * @param args.options.offset - The starting point for pagination.  Note, this is obfuscated and is not an index.
  * @param args.options.limit - The maximum number of resources to retrieve (default is 999).
  * @param args.options.ledgerVersion - The specific ledger version to query.
  * @group Implementation
@@ -161,7 +207,7 @@ export async function getTransactions(args: {
 export async function getResources(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  options?: PaginationArgs & LedgerVersionArg;
+  options?: { limit?: number } & LedgerVersionArg;
 }): Promise<MoveResource[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithObfuscatedCursor<{}, MoveResource[]>({
@@ -170,12 +216,43 @@ export async function getResources(args: {
     path: `accounts/${AccountAddress.from(accountAddress).toString()}/resources`,
     params: {
       ledger_version: options?.ledgerVersion,
-      offset: options?.offset,
       limit: options?.limit ?? 999,
     },
   });
 }
 
+/**
+ * Retrieves a page of resources associated with a specific account address.
+ *
+ * @param args - The arguments for retrieving resources.
+ * @param args.aptosConfig - The configuration settings for Aptos.
+ * @param args.accountAddress - The address of the account to fetch resources for.
+ * @param args.options - Optional pagination and ledger version parameters.
+ * @param args.options.cursor - The starting point for pagination.  Note, this is obfuscated and is not an index.
+ * @param args.options.limit - The maximum number of resources to retrieve (default is 100).
+ * @param args.options.ledgerVersion - The specific ledger version to query.
+ * @group Implementation
+ */
+export async function getResourcesPage(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  options?: CursorPaginationArgs & LedgerVersionArg;
+}): Promise<{ resources: MoveResource[]; cursor: string | undefined }> {
+  const { aptosConfig, accountAddress, options } = args;
+  const { response, cursor } = await getPageWithObfuscatedCursor<{}, MoveResource[]>({
+    aptosConfig,
+    originMethod: "getResourcesPage",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resources`,
+    params: {
+      ledger_version: options?.ledgerVersion,
+      cursor: options?.cursor,
+      limit: options?.limit ?? 100,
+    },
+  });
+
+  return { resources: response.data, cursor };
+}
+
 /**
  * Retrieves a specific resource of a given type for the specified account address.
  *

package/src/internal/move/jwks/build/jwk/BuildInfo.yaml

@@ -0,0 +1,56 @@
+---
+compiled_package_info:
+  package_name: jwk
+  address_alias_instantiation:
+    Extensions: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_framework: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_fungible_asset: 000000000000000000000000000000000000000000000000000000000000000a
+    aptos_std: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_token: "0000000000000000000000000000000000000000000000000000000000000003"
+    core_resources: 000000000000000000000000000000000000000000000000000000000a550c18
+    std: "0000000000000000000000000000000000000000000000000000000000000001"
+    vm: "0000000000000000000000000000000000000000000000000000000000000000"
+    vm_reserved: "0000000000000000000000000000000000000000000000000000000000000000"
+  source_digest: 3437D4FB002907781F0FE5D46FC4E668C8B8F0420AA77751774AD63B0C2730BF
+  build_flags:
+    dev_mode: false
+    test_mode: false
+    override_std: ~
+    generate_docs: false
+    generate_abis: false
+    generate_move_model: true
+    full_model_generation: false
+    install_dir: ~
+    force_recompilation: false
+    additional_named_addresses: {}
+    architecture: ~
+    fetch_deps_only: false
+    skip_fetch_latest_git_deps: false
+    compiler_config:
+      bytecode_version: 6
+      known_attributes:
+        - bytecode_instruction
+        - deprecated
+        - event
+        - expected_failure
+        - "fmt::skip"
+        - legacy_entry_fun
+        - "lint::allow_unsafe_randomness"
+        - "lint::skip"
+        - native_interface
+        - randomness
+        - resource_group
+        - resource_group_member
+        - test
+        - test_only
+        - verify_only
+        - view
+      skip_attribute_checks: false
+      compiler_version: ~
+      language_version: ~
+      experiments:
+        - optimize=on
+dependencies:
+  - AptosFramework
+  - AptosStdlib
+  - MoveStdlib