@aptos-labs/ts-sdk 4.0.0 → 5.1.0

package/dist/esm/version.d.mts

@@ -3,6 +3,6 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-declare const VERSION = "4.0.0";
+declare const VERSION = "5.1.0";
 
 export { VERSION };

package/dist/esm/version.mjs

@@ -1,2 +1,2 @@
-import{a}from"./chunk-6SLY7UV2.mjs";import"./chunk-KDMSOCZY.mjs";export{a as VERSION};
+import{a}from"./chunk-CIJA7ONS.mjs";import"./chunk-KDMSOCZY.mjs";export{a as VERSION};
 //# sourceMappingURL=version.mjs.map

package/package.json

@@ -52,50 +52,49 @@
   "dependencies": {
     "@aptos-labs/aptos-cli": "^1.0.2",
     "@aptos-labs/aptos-client": "^2.0.0",
-    "@noble/curves": "^1.6.0",
+    "@noble/curves": "^1.9.0",
     "@noble/hashes": "^1.5.0",
     "@scure/bip32": "^1.4.0",
     "@scure/bip39": "^1.3.0",
     "eventemitter3": "^5.0.1",
-    "form-data": "^4.0.0",
+    "form-data": "^4.0.4",
     "js-base64": "^3.7.7",
     "jwt-decode": "^4.0.0",
     "poseidon-lite": "^0.2.0"
   },
   "devDependencies": {
-    "@babel/traverse": "^7.26.10",
-    "@cucumber/cucumber": "^11.2.0",
+    "@babel/traverse": "^7.28.4",
+    "@cucumber/cucumber": "^12.2.0",
     "@eslint/eslintrc": "^3.3.1",
-    "@graphql-codegen/cli": "^5.0.5",
-    "@graphql-codegen/import-types-preset": "^3.0.0",
-    "@graphql-codegen/typescript": "^4.1.5",
-    "@graphql-codegen/typescript-graphql-request": "^6.2.0",
-    "@graphql-codegen/typescript-operations": "^4.5.1",
+    "@graphql-codegen/cli": "^6.0.0",
+    "@graphql-codegen/import-types-preset": "^3.0.1",
+    "@graphql-codegen/typescript": "^5.0.0",
+    "@graphql-codegen/typescript-graphql-request": "^6.3.0",
+    "@graphql-codegen/typescript-operations": "^5.0.0",
     "@types/base-64": "^1.0.2",
     "@types/jest": "^29.5.14",
-    "@types/jsonwebtoken": "^9.0.9",
-    "@types/node": "^20.17.25",
-    "@typescript-eslint/eslint-plugin": "^8.27.0",
-    "@typescript-eslint/parser": "^8.27.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^24.3.1",
+    "@typescript-eslint/eslint-plugin": "^8.43.0",
+    "@typescript-eslint/parser": "^8.43.0",
     "dotenv": "^16.4.7",
-    "eslint": "^9.23.0",
+    "eslint": "^9.35.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^10.1.1",
-    "eslint-plugin-import": "^2.31.0",
-    "graphql": "^16.10.0",
-    "globals": "^16.0.0",
-    "graphql-request": "^7.1.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "graphql": "^16.11.0",
+    "globals": "^16.4.0",
+    "graphql-request": "^7.2.0",
     "jest": "^29.7.0",
     "jsonwebtoken": "^9.0.2",
-    "prettier": "^3.5.3",
+    "prettier": "^3.6.2",
     "tree-kill": "^1.2.2",
-    "ts-jest": "^29.2.5",
-    "ts-loader": "^9.5.2",
-    "ts-node": "^10.9.2",
-    "tsup": "^8.4.0",
-    "typedoc": "^0.28.1",
-    "typedoc-plugin-missing-exports": "^4.0.0",
-    "typescript": "^5.8.2"
+    "ts-jest": "^29.4.1",
+    "ts-loader": "^9.5.4",
+    "tsup": "^8.5.0",
+    "typedoc": "^0.28.12",
+    "typedoc-plugin-missing-exports": "^4.1.0",
+    "typescript": "^5.8.3"
   },
-  "version": "4.0.0"
+  "version": "5.1.0"
 }

package/src/account/AbstractedAccount.ts

@@ -4,11 +4,15 @@ import { AbstractPublicKey, AbstractSignature } from "../core/crypto/abstraction
 import { SigningScheme, HexInput } from "../types";
 import { Account } from "./Account";
 import { AnyRawTransaction } from "../transactions/types";
-import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
-import { AccountAuthenticatorAbstraction } from "../transactions/authenticator/account";
+import {
+  generateSigningMessage,
+  generateSigningMessageForTransaction,
+} from "../transactions/transactionBuilder/signingMessage";
+import { AccountAbstractionMessage, AccountAuthenticatorAbstraction } from "../transactions/authenticator/account";
 import { Ed25519Account } from "./Ed25519Account";
 import { Serializer } from "../bcs/serializer";
 import { isValidFunctionInfo } from "../utils/helpers";
+import { ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT } from "../utils/const";
 
 type AbstractedAccountConstructorArgs = {
   /**
@@ -81,6 +85,11 @@ export class AbstractedAccount extends Account {
     });
   }
 
+  public static generateAccountAbstractionMessage(message: HexInput, functionInfo: string): HexInput {
+    const accountAbstractionMessage = new AccountAbstractionMessage(message, functionInfo);
+    return generateSigningMessage(accountAbstractionMessage.bcsToBytes(), ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT);
+  }
+
   signWithAuthenticator(message: HexInput): AccountAuthenticatorAbstraction {
     return new AccountAuthenticatorAbstraction(
       this.authenticationFunction,
@@ -90,7 +99,11 @@ export class AbstractedAccount extends Account {
   }
 
   signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorAbstraction {
-    return this.signWithAuthenticator(generateSigningMessageForTransaction(transaction));
+    const message = AbstractedAccount.generateAccountAbstractionMessage(
+      generateSigningMessageForTransaction(transaction),
+      this.authenticationFunction,
+    );
+    return this.signWithAuthenticator(message);
   }
 
   sign: (message: HexInput) => AbstractSignature;

package/src/account/DerivableAbstractedAccount.ts

@@ -1,10 +1,12 @@
 import { sha3_256 } from "@noble/hashes/sha3";
 import { Serializer } from "../bcs/serializer";
 import { AccountAddress } from "../core/accountAddress";
-import { AccountAuthenticatorAbstraction } from "../transactions/authenticator/account";
+import { AccountAbstractionMessage, AccountAuthenticatorAbstraction } from "../transactions/authenticator/account";
 import { HexInput } from "../types";
 import { isValidFunctionInfo } from "../utils/helpers";
 import { AbstractedAccount } from "./AbstractedAccount";
+import { generateSigningMessage } from "../transactions/transactionBuilder/signingMessage";
+import { ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT } from "../utils/const";
 
 type DerivableAbstractedAccountArgs = {
   /**

package/src/api/account.ts

@@ -40,6 +40,7 @@ import {
   getAccountsForPublicKey,
   getAccountTokensCount,
   getAccountTransactionsCount,
+  getBalance,
   getInfo,
   getModule,
   getModules,
@@ -780,15 +781,15 @@ export class Account {
   /**
    * Queries the current amount of a specified coin held by an account.
    *
+   * @deprecated Use `getBalance({ accountAddress, asset })` instead.
+   * This method is slated for removal in a future release.
+   *
    * @param args The parameters for querying the account's coin amount.
    * @param args.accountAddress The account address to query for the coin amount.
    * @param args.coinType The coin type to query. Note: If not provided, it may be automatically populated if `faMetadataAddress`
    * is specified.
    * @param args.faMetadataAddress The fungible asset metadata address to query. Note: If not provided, it may be automatically
    * populated if `coinType` is specified.
-   * @param args.minimumLedgerVersion Not used anymore, here for backward compatibility
-   * see https://github.com/aptos-labs/aptos-ts-sdk/pull/519, will be removed in the near future.
-   * Optional ledger version to sync up to before querying.
    * @returns The current amount of the specified coin held by the account.
    *
    * @example
@@ -799,13 +800,9 @@ export class Account {
    * const aptos = new Aptos(config);
    *
    * async function runExample() {
-   *   // Query the account's coin amount for a specific coin type
-   *   const accountCoinAmount = await aptos.getAccountCoinAmount({
-   *     accountAddress: "0x1", // replace with a real account address
-   *     coinType: "0x1::aptos_coin::AptosCoin" // specify the coin type
-   *   });
-   *
-   *   console.log(`Account coin amount: ${accountCoinAmount}`);
+   *   // Prefer the new API
+   *   const amount = await aptos.getBalance({ accountAddress: "0x1", asset: "0x1::aptos_coin::AptosCoin" });
+   *   console.log(`Balance: ${amount}`);
    * }
    * runExample().catch(console.error);
    * ```
@@ -815,18 +812,9 @@ export class Account {
     accountAddress: AccountAddressInput;
     coinType?: MoveStructId;
     faMetadataAddress?: AccountAddressInput;
-    minimumLedgerVersion?: AnyNumber;
   }): Promise<number> {
-    const { accountAddress, coinType, faMetadataAddress, minimumLedgerVersion } = args;
+    const { accountAddress, coinType, faMetadataAddress } = args;
 
-    if (minimumLedgerVersion) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        `minimumLedgerVersion is not used anymore, here for backward 
-        compatibility see https://github.com/aptos-labs/aptos-ts-sdk/pull/519, 
-        will be removed in the near future`,
-      );
-    }
     // Attempt to populate the CoinType field if the FA address is provided.
     // We cannot do this internally due to dependency cycles issue.
     let coinAssetType: MoveStructId | undefined = coinType;
@@ -835,15 +823,15 @@ export class Account {
         async () => {
           try {
             const pairedCoinTypeStruct = (
-              await view({
+              await view<[{ vec: [MoveStructId] }]>({
                 aptosConfig: this.config,
                 payload: { function: "0x1::coin::paired_coin", functionArguments: [faMetadataAddress] },
               })
-            ).at(0) as { vec: MoveValue[] };
+            )[0];
 
             // Check if the Option has a value, and if so, parse the struct
             if (pairedCoinTypeStruct.vec.length > 0 && isEncodedStruct(pairedCoinTypeStruct.vec[0])) {
-              return parseEncodedStruct(pairedCoinTypeStruct.vec[0]) as MoveStructId;
+              return parseEncodedStruct(pairedCoinTypeStruct.vec[0]);
             }
           } catch (error) {
             /* No paired coin type found */
@@ -902,6 +890,31 @@ export class Account {
     return parseInt(balanceStr, 10);
   }
 
+  /**
+   * Retrieves the balance for an account and asset.
+   *
+   * @param args The parameters for the balance query.
+   * @param args.accountAddress The account address to query.
+   * @param args.asset The asset to query: Move struct ID (e.g., `0x1::aptos_coin::AptosCoin`) or FA metadata address.
+   * @returns The balance as a number.
+   *
+   * @example
+   * ```ts
+   * const aptos = new Aptos(new AptosConfig());
+   * // APT coin by type
+   * const apt = await aptos.getBalance({ accountAddress: "0x1", asset: "0x1::aptos_coin::AptosCoin" });
+   * // Some FA by metadata address
+   * const fa = await aptos.getBalance({ accountAddress: "0x1", asset: "0xa" });
+   * ```
+   * @group Account
+   */
+  async getBalance(args: {
+    accountAddress: AccountAddressInput;
+    asset: MoveStructId | AccountAddressInput;
+  }): Promise<number> {
+    return getBalance({ aptosConfig: this.config, ...args });
+  }
+
   /**
    * Queries an account's owned objects.
    *

package/src/api/transaction.ts

@@ -36,14 +36,14 @@ import {
   InputGenerateTransactionPayloadData,
   InputTransactionPluginData,
 } from "../transactions";
-import { AccountAddressInput, AuthenticationKey, Ed25519PrivateKey } from "../core";
-import { Account } from "../account";
+import { AccountAddressInput, AccountPublicKey, AuthenticationKey, Ed25519PrivateKey } from "../core";
+import { Account, Ed25519Account, MultiEd25519Account } from "../account";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";
 import { TransactionManagement } from "./transactionSubmission/management";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
-import { rotateAuthKey } from "../internal/account";
+import { rotateAuthKey, rotateAuthKeyUnverified } from "../internal/account";
 
 /**
  * Represents a transaction in the Aptos blockchain,
@@ -480,43 +480,33 @@ export class Transaction {
    *
    * @param args - The arguments for rotating the authentication key.
    * @param args.fromAccount - The account from which the authentication key will be rotated.
-   * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey or toAuthKey.
-   * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount or toAuthKey.
-   * @param args.toAuthKey - (Optional) The new authentication key to rotate to. Can only be used with dangerouslySkipVerification=true.
-   * @param args.dangerouslySkipVerification - (Optional) If true, skips verification steps after rotation. Required when using toAuthKey.
+   * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey.
+   * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount.
    *
    * @remarks
    * This function supports three modes of rotation:
    * 1. Using a target Account object (toAccount)
    * 2. Using a new private key (toNewPrivateKey)
-   * 3. Using a raw authentication key (toAuthKey) - requires dangerouslySkipVerification=true
    *
-   * When not using dangerouslySkipVerification, the function performs additional safety checks and account setup.
+   * For Ed25519 accounts, the function will use a challenge-based rotation that requires signatures from both the old and new keys.
+   * For multi-key accounts like MultiEd25519Account, the function will use a challenge-based rotation that requires signatures from both keys.
+   * For other account types, the function will use an unverified rotation that only requires the new public key.
    *
-   * If the new key is a multi key, skipping verification is dangerous because verification will publish the public key onchain and
-   * prevent users from being locked out of the account from loss of knowledge of one of the public keys.
-   *
-   * @returns PendingTransactionResponse
+   * @returns SimpleTransaction that can be submitted to rotate the auth key
    *
    * @example
    * ```typescript
-   * import { Aptos, AptosConfig, Network, Account, PrivateKey } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Rotate the authentication key for an account
-   *   const response = await aptos.rotateAuthKey({
-   *     // replace with a real account
-   *     fromAccount: Account.generate(),
-   *     // replace with a real private key
-   *     toNewPrivateKey: new PrivateKey("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"),
-   *   });
-   *
-   *   console.log(response);
-   * }
-   * runExample().catch(console.error);
+   * // Create and submit transaction to rotate the auth key
+   * const transaction = await aptos.rotateAuthKey({
+   *   fromAccount,
+   *   toAccount: toAccount,
+   * });
+   *
+   * // Sign and submit the transaction
+   * const pendingTransaction = await aptos.signAndSubmitTransaction({
+   *   signer: fromAccount,
+   *   transaction,
+   * });
    * ```
    * @group Transaction
    */
@@ -524,15 +514,48 @@ export class Transaction {
     args: {
       fromAccount: Account;
       options?: InputGenerateTransactionOptions;
-    } & (
-      | { toAccount: Account; dangerouslySkipVerification?: never }
-      | { toNewPrivateKey: Ed25519PrivateKey; dangerouslySkipVerification?: never }
-      | { toAuthKey: AuthenticationKey; dangerouslySkipVerification: true }
-    ),
-  ): Promise<PendingTransactionResponse> {
+    } & ({ toAccount: Ed25519Account | MultiEd25519Account } | { toNewPrivateKey: Ed25519PrivateKey }),
+  ): Promise<SimpleTransaction> {
     return rotateAuthKey({ aptosConfig: this.config, ...args });
   }
 
+  /**
+   * Rotates the authentication key for a given account without verifying the new key.
+   *
+   * Accounts with their auth key rotated via this function will be derivable via the `getAccountsForPublicKey` and
+   * `deriveOwnedAccountsFromSigner` functions however the public key will be unverified (no proof of ownership). Thus
+   * includeUnverified must be set to true to derive the account until the public key is verified via signing a transaction.
+   *
+   * @param args - The arguments for rotating the authentication key.
+   * @param args.fromAccount - The account from which the authentication key will be rotated.
+   * @param args.toNewPublicKey - The new public key to rotate to.
+   *
+   * @returns A simple transaction object that can be submitted to the network.
+   *
+   * @example
+   * ```typescript
+   * // Create and submit transaction to rotate the auth key
+   * const transaction = await aptos.rotateAuthKeyUnverified({
+   *   fromAccount,
+   *   toNewPublicKey,
+   * });
+   *
+   * // Sign and submit the transaction
+   * const pendingTransaction = await aptos.signAndSubmitTransaction({
+   *   signer: fromAccount,
+   *   transaction,
+   * });
+   * ```
+   * @group Transaction
+   */
+  async rotateAuthKeyUnverified(args: {
+    fromAccount: Account;
+    options?: InputGenerateTransactionOptions;
+    toNewPublicKey: AccountPublicKey;
+  }): Promise<SimpleTransaction> {
+    return rotateAuthKeyUnverified({ aptosConfig: this.config, ...args });
+  }
+
   /**
    * Sign a transaction that can later be submitted to the chain.
    * This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.

package/src/core/crypto/index.ts

@@ -13,6 +13,7 @@ export * from "./poseidon";
 export * from "./privateKey";
 export * from "./publicKey";
 export * from "./secp256k1";
+export * from "./secp256r1";
 export * from "./signature";
 export * from "./singleKey";
 export * from "./types";

package/src/core/crypto/privateKey.ts

@@ -45,6 +45,7 @@ export class PrivateKey {
   public static readonly AIP80_PREFIXES = {
     [PrivateKeyVariants.Ed25519]: "ed25519-priv-",
     [PrivateKeyVariants.Secp256k1]: "secp256k1-priv-",
+    [PrivateKeyVariants.Secp256r1]: "secp256r1-priv-",
   };
 
   /**

package/src/core/crypto/secp256k1.ts

@@ -32,6 +32,9 @@ export class Secp256k1PublicKey extends PublicKey {
   // Hex value of the public key
   private readonly key: Hex;
 
+  // Identifier to distinguish from Secp256k1PublicKey
+  public readonly keyType: string = "secp256k1";
+
   /**
    * Create a new PublicKey instance from a HexInput, which can be a string or Uint8Array.
    * This constructor validates the length of the provided signature data.
@@ -171,7 +174,12 @@ export class Secp256k1PublicKey extends PublicKey {
    * @category Serialization
    */
   static isInstance(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
-    return "key" in publicKey && (publicKey.key as any)?.data?.length === Secp256k1PublicKey.LENGTH;
+    return (
+      "key" in publicKey &&
+      (publicKey.key as any)?.data?.length === Secp256k1PublicKey.LENGTH &&
+      "keyType" in publicKey &&
+      (publicKey as any).keyType === "secp256k1"
+    );
   }
 }