@aptos-labs/ts-sdk 4.0.0-zeta.0 → 5.0.0

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

@@ -786,9 +786,6 @@ export class Account {
    * 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
@@ -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 */

package/src/api/index.ts

@@ -3,4 +3,3 @@
 
 export * from "./aptos";
 export * from "./aptosConfig";
-export * from "./manager";

package/src/transactions/authenticator/account.ts

@@ -9,7 +9,7 @@ import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
 import { MultiKey, MultiKeySignature } from "../../core/crypto/multiKey";
 import { AccountAuthenticatorVariant, HexInput, MoveFunctionId } from "../../types";
-import { AbstractionAuthDataVariant } from "../../types/abstraction";
+import { AASigningDataVariant, AbstractAuthenticationDataVariant } from "../../types/abstraction";
 import { AccountAddress, Hex } from "../../core";
 import { getFunctionParts, isValidFunctionInfo } from "../../utils/helpers";
 
@@ -269,12 +269,22 @@ export class AccountAuthenticatorNoAccountAuthenticator extends AccountAuthentic
   }
 }
 
+/**
+ * Represents an account authenticator that supports abstract authentication.
+ *
+ * @param functionInfo - The function info of the authentication function.
+ * @param signingMessageDigest - The digest of the signing message.
+ * @param abstractionSignature - The signature of the authentication function.
+ * @param accountIdentity - optional. The account identity for DAA.
+ * @group Implementation
+ * @category Transactions
+ */
 export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
   public readonly functionInfo: string;
 
   public readonly signingMessageDigest: Hex;
 
-  public readonly authenticator: Uint8Array;
+  public readonly abstractionSignature: Uint8Array;
 
   /**
    * DAA, which is extended of the AA module, requires an account identity
@@ -284,7 +294,7 @@ export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
   constructor(
     functionInfo: string,
     signingMessageDigest: HexInput,
-    authenticator: Uint8Array,
+    abstractionSignature: Uint8Array,
     accountIdentity?: Uint8Array,
   ) {
     super();
@@ -292,7 +302,7 @@ export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
       throw new Error(`Invalid function info ${functionInfo} passed into AccountAuthenticatorAbstraction`);
     }
     this.functionInfo = functionInfo;
-    this.authenticator = authenticator;
+    this.abstractionSignature = abstractionSignature;
     this.signingMessageDigest = Hex.fromHexInput(Hex.fromHexInput(signingMessageDigest).toUint8Array());
     this.accountIdentity = accountIdentity;
   }
@@ -304,15 +314,15 @@ export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
     serializer.serializeStr(moduleName);
     serializer.serializeStr(functionName);
     if (this.accountIdentity) {
-      serializer.serializeU32AsUleb128(AbstractionAuthDataVariant.DerivableV1);
+      serializer.serializeU32AsUleb128(AbstractAuthenticationDataVariant.DerivableV1);
     } else {
-      serializer.serializeU32AsUleb128(AbstractionAuthDataVariant.V1);
+      serializer.serializeU32AsUleb128(AbstractAuthenticationDataVariant.V1);
     }
     serializer.serializeBytes(this.signingMessageDigest.toUint8Array());
     if (this.accountIdentity) {
-      serializer.serializeBytes(this.authenticator);
+      serializer.serializeBytes(this.abstractionSignature);
     } else {
-      serializer.serializeFixedBytes(this.authenticator);
+      serializer.serializeFixedBytes(this.abstractionSignature);
     }
 
     if (this.accountIdentity) {
@@ -321,31 +331,75 @@ export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
   }
 
   static load(deserializer: Deserializer): AccountAuthenticatorAbstraction {
+    // deserialize the function info
     const moduleAddress = AccountAddress.deserialize(deserializer);
     const moduleName = deserializer.deserializeStr();
     const functionName = deserializer.deserializeStr();
+    // deserialize the variant
     const variant = deserializer.deserializeUleb128AsU32();
-    if (variant === AbstractionAuthDataVariant.V1) {
-      const signingMessageDigest = deserializer.deserializeBytes();
-      const authenticator = deserializer.deserializeFixedBytes(deserializer.remaining());
+    // deserialize the signing message digest
+    const signingMessageDigest = deserializer.deserializeBytes();
+
+    if (variant === AbstractAuthenticationDataVariant.V1) {
+      const abstractionSignature = deserializer.deserializeFixedBytes(deserializer.remaining());
       return new AccountAuthenticatorAbstraction(
         `${moduleAddress}::${moduleName}::${functionName}`,
         signingMessageDigest,
-        authenticator,
+        abstractionSignature,
       );
     }
-    if (variant === AbstractionAuthDataVariant.DerivableV1) {
-      const signingMessageDigest = deserializer.deserializeBytes();
-      const abstractSignature = deserializer.deserializeBytes();
-
+    if (variant === AbstractAuthenticationDataVariant.DerivableV1) {
+      const abstractionSignature = deserializer.deserializeBytes();
       const abstractPublicKey = deserializer.deserializeBytes();
       return new AccountAuthenticatorAbstraction(
         `${moduleAddress}::${moduleName}::${functionName}`,
         signingMessageDigest,
-        abstractSignature,
+        abstractionSignature,
         abstractPublicKey,
       );
     }
     throw new Error(`Unknown variant index for AccountAuthenticatorAbstraction: ${variant}`);
   }
 }
+
+/**
+ * Represents an account abstraction message that contains the original signing message and the function info.
+ *
+ * @param originalSigningMessage - The original signing message.
+ * @param functionInfo - The function info of the authentication function.
+ * @group Implementation
+ * @category Transactions
+ */
+export class AccountAbstractionMessage extends Serializable {
+  public readonly originalSigningMessage: Hex;
+
+  public readonly functionInfo: string;
+
+  constructor(originalSigningMessage: HexInput, functionInfo: string) {
+    super();
+    this.originalSigningMessage = Hex.fromHexInput(Hex.fromHexInput(originalSigningMessage).toUint8Array());
+    this.functionInfo = functionInfo;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(AASigningDataVariant.V1);
+    serializer.serializeBytes(this.originalSigningMessage.toUint8Array());
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(this.functionInfo as MoveFunctionId);
+    AccountAddress.fromString(moduleAddress).serialize(serializer);
+    serializer.serializeStr(moduleName);
+    serializer.serializeStr(functionName);
+  }
+
+  static deserialize(deserializer: Deserializer): AccountAbstractionMessage {
+    const variant = deserializer.deserializeUleb128AsU32();
+    if (variant !== AASigningDataVariant.V1) {
+      throw new Error(`Unknown variant index for AccountAbstractionMessage: ${variant}`);
+    }
+    const originalSigningMessage = deserializer.deserializeBytes();
+    const functionInfoModuleAddress = AccountAddress.deserialize(deserializer);
+    const functionInfoModuleName = deserializer.deserializeStr();
+    const functionInfoFunctionName = deserializer.deserializeStr();
+    const functionInfo = `${functionInfoModuleAddress}::${functionInfoModuleName}::${functionInfoFunctionName}`;
+    return new AccountAbstractionMessage(originalSigningMessage, functionInfo);
+  }
+}

package/src/types/abstraction.ts

@@ -1,7 +1,14 @@
 /**
- * The variant for the AbstractionAuthData enum.
+ * The variant for the AbstractAuthenticationData enum.
  */
-export enum AbstractionAuthDataVariant {
+export enum AbstractAuthenticationDataVariant {
   V1 = 0,
   DerivableV1 = 1,
 }
+
+/**
+ * The variant for the AASigningData enum.
+ */
+export enum AASigningDataVariant {
+  V1 = 0,
+}

package/src/utils/const.ts

@@ -70,6 +70,8 @@ export const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
  */
 export const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";
 
+export const ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT = "APTOS::AASigningData";
+
 /**
  * Supported processor types for the indexer API, sourced from the processor_status table in the indexer database.
  * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://api.mainnet.aptoslabs.com/v1/graphql}

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "4.0.0";
+export const VERSION = "5.0.0";