@aptos-labs/ts-sdk 1.33.2 → 1.35.0-zeta.0

package/src/internal/queries/getAuthKeysForPublicKey.graphql

@@ -0,0 +1,9 @@
+query getAuthKeysForPublicKey($where_condition: public_key_auth_keys_bool_exp) {
+  public_key_auth_keys(where: $where_condition) {
+    public_key
+    public_key_type
+    auth_key
+    last_transaction_version
+    verified
+  }
+}

package/src/internal/queries/getMultiKeyForAuthKey.graphql

@@ -0,0 +1,9 @@
+query getMultiKeyForAuthKey($where_condition: auth_key_multikey_layout_bool_exp) {
+  auth_key_multikey_layout(where: $where_condition) {
+    auth_key
+    last_transaction_version
+    multikey_layout_with_prefixes
+    multikey_type
+    signatures_required
+  }
+}

package/src/internal/queries/getSignatures.graphql

@@ -0,0 +1,13 @@
+query getSignatures($where_condition: signatures_bool_exp, $offset: Int, $limit: Int, $order_by: [signatures_order_by!]) {
+  signatures(where: $where_condition, offset: $offset, limit: $limit, order_by: $order_by ) {
+    signature
+    public_key
+    public_key_indices
+    type
+    signer
+    transaction_version
+    threshold
+    is_sender_primary
+  }
+}
+

package/src/internal/transactionSubmission.ts

@@ -11,7 +11,13 @@ import { Deserializer, MoveVector, U8 } from "../bcs";
 import { postAptosFullNode } from "../client";
 import { Account, AbstractKeylessAccount, isKeylessSigner } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { FederatedKeylessPublicKey, KeylessPublicKey, KeylessSignature, PrivateKeyInput } from "../core/crypto";
+import {
+  Ed25519PrivateKey,
+  FederatedKeylessPublicKey,
+  KeylessPublicKey,
+  KeylessSignature,
+  PrivateKeyInput,
+} from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
 import { RotationProofChallenge } from "../transactions/instances/rotationProofChallenge";
 import {
@@ -33,10 +39,21 @@ import {
   EntryFunctionABI,
 } from "../transactions/types";
 import { getInfo } from "./account";
-import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
+import {
+  UserTransactionResponse,
+  PendingTransactionResponse,
+  MimeType,
+  HexInput,
+  TransactionResponse,
+  CommittedTransactionResponse,
+} from "../types";
 import { SignedTransaction, TypeTagU8, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 import { MultiAgentTransaction } from "../transactions/instances/multiAgentTransaction";
+import { MultiEd25519Account } from "../account/MultiEd25519Account";
+import { AuthenticationKey, Hex } from "../core";
+import { waitForTransaction } from "./transaction";
+import { transferCoinTransaction } from "./coin";
 
 /**
  * We are defining function signatures, each with its specific input and output.
@@ -457,6 +474,11 @@ const rotateAuthKeyAbi: EntryFunctionABI = {
   ],
 };
 
+const rotateAuthKeyUnverifiedAbi: EntryFunctionABI = {
+  typeParameters: [],
+  parameters: [TypeTagVector.u8()],
+};
+
 /**
  * Rotates the authentication key for a given account, allowing for enhanced security and management of account access.
  *
@@ -474,8 +496,8 @@ const rotateAuthKeyAbi: EntryFunctionABI = {
 export async function rotateAuthKey(args: {
   aptosConfig: AptosConfig;
   fromAccount: Account;
-  toNewPrivateKey: PrivateKeyInput;
-}): Promise<TransactionResponse> {
+  toNewPrivateKey: Ed25519PrivateKey;
+}): Promise<PendingTransactionResponse> {
   const { aptosConfig, fromAccount, toNewPrivateKey } = args;
   const accountInfo = await getInfo({
     aptosConfig,
@@ -519,3 +541,102 @@ export async function rotateAuthKey(args: {
     transaction: rawTxn,
   });
 }
+
+export async function rotateAuthKeyToMultiEd25519(args: {
+  aptosConfig: AptosConfig;
+  fromAccount: Account;
+  multiEd25519Account: MultiEd25519Account;
+}): Promise<PendingTransactionResponse> {
+  const { aptosConfig, fromAccount, multiEd25519Account } = args;
+  const accountInfo = await getInfo({
+    aptosConfig,
+    accountAddress: fromAccount.accountAddress,
+  });
+
+  const newAccount = multiEd25519Account;
+
+  const challenge = new RotationProofChallenge({
+    sequenceNumber: BigInt(accountInfo.sequence_number),
+    originator: fromAccount.accountAddress,
+    currentAuthKey: AccountAddress.from(accountInfo.authentication_key),
+    newPublicKey: newAccount.publicKey,
+  });
+
+  // Sign the challenge
+  const challengeHex = challenge.bcsToBytes();
+  const proofSignedByCurrentPrivateKey = fromAccount.sign(challengeHex);
+  const proofSignedByNewPrivateKey = newAccount.sign(challengeHex);
+
+  // Generate transaction
+  const rawTxn = await generateTransaction({
+    aptosConfig,
+    sender: fromAccount.accountAddress,
+    data: {
+      function: "0x1::account::rotate_authentication_key",
+      functionArguments: [
+        new U8(fromAccount.signingScheme), // from scheme
+        MoveVector.U8(fromAccount.publicKey.toUint8Array()),
+        new U8(newAccount.signingScheme), // to scheme
+        MoveVector.U8(newAccount.publicKey.toUint8Array()),
+        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),
+        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array()),
+      ],
+      abi: rotateAuthKeyAbi,
+    },
+  });
+  return signAndSubmitTransaction({
+    aptosConfig,
+    signer: fromAccount,
+    transaction: rawTxn,
+  });
+}
+
+export async function rotateAuthKeyWithVerificationTransaction(args: {
+  aptosConfig: AptosConfig;
+  fromAccount: Account;
+  toAccount: Account;
+}): Promise<CommittedTransactionResponse> {
+  const { aptosConfig, fromAccount, toAccount } = args;
+
+  // Generate transaction
+  const rawTxn = await generateTransaction({
+    aptosConfig,
+    sender: fromAccount.accountAddress,
+    data: {
+      function: "0x1::account::rotate_authentication_key_call",
+      functionArguments: [MoveVector.U8(toAccount.publicKey.authKey().toUint8Array())],
+      abi: rotateAuthKeyUnverifiedAbi,
+    },
+  });
+  const pendingTxn = await signAndSubmitTransaction({
+    aptosConfig,
+    signer: fromAccount,
+    transaction: rawTxn,
+  });
+  const txnResponse = await waitForTransaction({
+    aptosConfig,
+    transactionHash: pendingTxn.hash,
+  });
+  if (!txnResponse.success) {
+    throw new Error(`Failed to rotate authentication key - ${txnResponse}`);
+  }
+  const coinTxn = await transferCoinTransaction({
+    aptosConfig,
+    sender: toAccount.accountAddress,
+    recipient: toAccount.accountAddress,
+    amount: 1,
+  });
+  const pendingCoinTxn = await signAndSubmitTransaction({
+    aptosConfig,
+    signer: fromAccount,
+    transaction: coinTxn,
+  });
+  const coinTxnResponse = await waitForTransaction({
+    aptosConfig,
+    transactionHash: pendingCoinTxn.hash,
+  });
+  if (!coinTxnResponse.success) {
+    throw new Error(`Failed to verify authentication key - ${coinTxnResponse}`);
+  }
+  return coinTxnResponse;
+}

package/src/internal/view.ts

@@ -27,7 +27,7 @@ export async function view<T extends Array<MoveValue> = Array<MoveValue>>(args:
   viewFunctionPayload.serialize(serializer);
   const bytes = serializer.toUint8Array();
 
-  const { data } = await postAptosFullNode<Uint8Array, MoveValue[]>({
+  const { data } = await postAptosFullNode<Uint8Array, T>({
     aptosConfig,
     path: "view",
     originMethod: "view",
@@ -36,7 +36,7 @@ export async function view<T extends Array<MoveValue> = Array<MoveValue>>(args:
     body: bytes,
   });
 
-  return data as T;
+  return data;
 }
 
 export async function viewJson<T extends Array<MoveValue> = Array<MoveValue>>(args: {
@@ -45,7 +45,7 @@ export async function viewJson<T extends Array<MoveValue> = Array<MoveValue>>(ar
   options?: LedgerVersionArg;
 }): Promise<T> {
   const { aptosConfig, payload, options } = args;
-  const { data } = await postAptosFullNode<ViewFunctionJsonPayload, MoveValue[]>({
+  const { data } = await postAptosFullNode<ViewFunctionJsonPayload, T>({
     aptosConfig,
     originMethod: "viewJson",
     path: "view",
@@ -57,5 +57,5 @@ export async function viewJson<T extends Array<MoveValue> = Array<MoveValue>>(ar
     },
   });
 
-  return data as T;
+  return data;
 }

package/src/transactions/authenticator/account.ts

@@ -8,7 +8,10 @@ import { AnyPublicKey, AnySignature } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
 import { MultiKey, MultiKeySignature } from "../../core/crypto/multiKey";
-import { AccountAuthenticatorVariant } from "../../types";
+import { AccountAuthenticatorVariant, HexInput, MoveFunctionId } from "../../types";
+import { AbstractionAuthDataVariant } from "../../types/abstraction";
+import { AccountAddress, Hex } from "../../core";
+import { getFunctionParts, isValidFunctionInfo } from "../../utils/helpers";
 
 /**
  * Represents an account authenticator that can handle multiple authentication variants.
@@ -43,6 +46,8 @@ export abstract class AccountAuthenticator extends Serializable {
         return AccountAuthenticatorMultiKey.load(deserializer);
       case AccountAuthenticatorVariant.NoAccountAuthenticator:
         return AccountAuthenticatorNoAccountAuthenticator.load(deserializer);
+      case AccountAuthenticatorVariant.Abstraction:
+        return AccountAuthenticatorAbstraction.load(deserializer);
       default:
         throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
     }
@@ -263,3 +268,49 @@ export class AccountAuthenticatorNoAccountAuthenticator extends AccountAuthentic
     return new AccountAuthenticatorNoAccountAuthenticator();
   }
 }
+
+export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
+  public readonly functionInfo: string;
+
+  public readonly signingMessageDigest: Hex;
+
+  public readonly authenticator: Hex;
+
+  constructor(functionInfo: string, signingMessageDigest: HexInput, authenticator: HexInput) {
+    super();
+    if (!isValidFunctionInfo(functionInfo)) {
+      throw new Error(`Invalid function info ${functionInfo} passed into AccountAuthenticatorAbstraction`);
+    }
+    this.functionInfo = functionInfo;
+    this.authenticator = Hex.fromHexInput(authenticator);
+    this.signingMessageDigest = Hex.fromHexInput(Hex.fromHexInput(signingMessageDigest).toUint8Array());
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.Abstraction);
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(this.functionInfo as MoveFunctionId);
+    AccountAddress.fromString(moduleAddress).serialize(serializer);
+    serializer.serializeStr(moduleName);
+    serializer.serializeStr(functionName);
+    serializer.serializeU32AsUleb128(AbstractionAuthDataVariant.V1);
+    serializer.serializeBytes(this.signingMessageDigest.toUint8Array());
+    serializer.serializeFixedBytes(this.authenticator.toUint8Array());
+  }
+
+  static load(deserializer: Deserializer): AccountAuthenticatorAbstraction {
+    const moduleAddress = AccountAddress.deserialize(deserializer);
+    const moduleName = deserializer.deserializeStr();
+    const functionName = deserializer.deserializeStr();
+    const variant = deserializer.deserializeUleb128AsU32();
+    if (variant === AbstractionAuthDataVariant.V1) {
+      const signingMessageDigest = deserializer.deserializeBytes();
+      const authenticator = deserializer.deserializeFixedBytes(deserializer.remaining());
+      return new AccountAuthenticatorAbstraction(
+        `${moduleAddress}::${moduleName}::${functionName}`,
+        signingMessageDigest,
+        authenticator,
+      );
+    }
+    throw new Error(`Unknown variant index for AccountAuthenticatorAbstraction: ${variant}`);
+  }
+}

package/src/transactions/index.ts

@@ -7,3 +7,4 @@ export * from "./transactionBuilder";
 export * from "./typeTag";
 export * from "./typeTag/parser";
 export * from "./types";
+export * from "./scriptComposer";

package/src/transactions/scriptComposer/index.ts

@@ -0,0 +1,87 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { ScriptComposerWasm } from "@aptos-labs/script-composer-pack";
+import { AptosApiType, getFunctionParts } from "../../utils";
+import { AptosConfig } from "../../api/aptosConfig";
+import { InputBatchedFunctionData } from "../types";
+import { fetchMoveFunctionAbi, standardizeTypeTags } from "../transactionBuilder";
+import { CallArgument } from "../../types";
+import { convertCallArgument } from "../transactionBuilder/remoteAbi";
+
+/**
+ * A wrapper class around TransactionComposer, which is a WASM library compiled
+ * from aptos-core/aptos-move/script-composer.
+ * This class allows the SDK caller to build a transaction that invokes multiple Move functions
+ * and allow for arguments to be passed around.
+ * */
+export class AptosScriptComposer {
+  private config: AptosConfig;
+
+  private builder?: any;
+
+  private static transactionComposer?: any;
+
+  constructor(aptosConfig: AptosConfig) {
+    this.config = aptosConfig;
+    this.builder = undefined;
+  }
+
+  // Initializing the wasm needed for the script composer, must be called
+  // before using the composer.
+  async init() {
+    if (!AptosScriptComposer.transactionComposer) {
+      const module = await import("@aptos-labs/script-composer-pack");
+      const { TransactionComposer, initSync } = module;
+      if (!ScriptComposerWasm.isInitialized) {
+        ScriptComposerWasm.init();
+      }
+      initSync({ module: ScriptComposerWasm.wasm });
+      AptosScriptComposer.transactionComposer = TransactionComposer;
+    }
+    this.builder = AptosScriptComposer.transactionComposer.single_signer();
+  }
+
+  // Add a move function invocation to the TransactionComposer.
+  //
+  // Similar to how to create an entry function, the difference is that input arguments could
+  // either be a `CallArgument` which represents an abstract value returned from a previous Move call
+  // or the regular entry function arguments.
+  //
+  // The function would also return a list of `CallArgument` that can be passed on to future calls.
+  async addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]> {
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(input.function);
+    const nodeUrl = this.config.getRequestUrl(AptosApiType.FULLNODE);
+
+    // Load the calling module into the builder.
+    await this.builder.load_module(nodeUrl, `${moduleAddress}::${moduleName}`);
+
+    // Load the calling type arguments into the loader.
+    if (input.typeArguments !== undefined) {
+      await Promise.all(input.typeArguments.map((typeTag) => this.builder.load_type_tag(nodeUrl, typeTag.toString())));
+    }
+    const typeArguments = standardizeTypeTags(input.typeArguments);
+    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
+    // Check the type argument count against the ABI
+    if (typeArguments.length !== functionAbi.typeParameters.length) {
+      throw new Error(
+        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,
+      );
+    }
+
+    const functionArguments: CallArgument[] = input.functionArguments.map((arg, i) =>
+      convertCallArgument(arg, functionName, functionAbi, i, typeArguments),
+    );
+
+    return this.builder.add_batched_call(
+      `${moduleAddress}::${moduleName}`,
+      functionName,
+      typeArguments.map((arg) => arg.toString()),
+      functionArguments,
+    );
+  }
+
+  build(): Uint8Array {
+    return this.builder.generate_batched_calls(true);
+  }
+}

package/src/transactions/transactionBuilder/helpers.ts

@@ -10,7 +10,7 @@ import {
 } from "../types";
 import { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
 import { AccountAddress } from "../../core";
-import { MoveFunction, MoveFunctionId } from "../../types";
+import { MoveFunction } from "../../types";
 
 /**
  * Determines if the provided argument is of type boolean.
@@ -317,24 +317,3 @@ export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
   }
   return index;
 }
-
-/**
- * Splits a function identifier into its constituent parts: module address, module name, and function name.
- * This function helps in validating and extracting details from a function identifier string.
- *
- * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
- * @returns An object containing the module address, module name, and function name.
- * @throws Error if the function identifier does not contain exactly three parts.
- * @group Implementation
- * @category Transactions
- */
-export function getFunctionParts(functionArg: MoveFunctionId) {
-  const funcNameParts = functionArg.split("::");
-  if (funcNameParts.length !== 3) {
-    throw new Error(`Invalid function ${functionArg}`);
-  }
-  const moduleAddress = funcNameParts[0];
-  const moduleName = funcNameParts[1];
-  const functionName = funcNameParts[2];
-  return { moduleAddress, moduleName, functionName };
-}

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -45,7 +45,7 @@ import {
   throwTypeMismatch,
   convertNumber,
 } from "./helpers";
-import { MoveFunction } from "../../types";
+import { CallArgument, MoveFunction } from "../../types";
 
 const TEXT_ENCODER = new TextEncoder();
 
@@ -96,6 +96,34 @@ export async function fetchFunctionAbi(
   return undefined;
 }
 
+/**
+ * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.
+ * @param moduleAddress
+ * @param moduleName
+ * @param functionName
+ * @param aptosConfig
+ */
+export async function fetchMoveFunctionAbi(
+  moduleAddress: string,
+  moduleName: string,
+  functionName: string,
+  aptosConfig: AptosConfig,
+): Promise<FunctionABI> {
+  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);
+  if (!functionAbi) {
+    throw new Error(`Could not find function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
+  }
+  const params: TypeTag[] = [];
+  for (let i = 0; i < functionAbi.params.length; i += 1) {
+    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
+  }
+
+  return {
+    typeParameters: functionAbi.generic_type_params,
+    parameters: params,
+  };
+}
+
 /**
  * Fetches the ABI for an entry function from the specified module address.
  * This function validates if the ABI corresponds to an entry function and retrieves its parameters.
@@ -191,6 +219,32 @@ export async function fetchViewFunctionAbi(
   };
 }
 
+/**
+ * Converts a entry function argument into CallArgument, if necessary.
+ * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ *
+ * @param functionName - The name of the function for which the argument is being converted.
+ * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
+ * @param argument - The argument to be converted, which can be of various types. If the argument is already
+ *                   CallArgument returned from TransactionComposer it would be returned immediately.
+ * @param position - The index of the argument in the function's parameter list.
+ * @param genericTypeParams - An array of type tags for any generic type parameters.
+ */
+export function convertCallArgument(
+  argument: CallArgument | EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
+  functionName: string,
+  functionAbi: FunctionABI,
+  position: number,
+  genericTypeParams: Array<TypeTag>,
+): CallArgument {
+  if (argument instanceof CallArgument) {
+    return argument;
+  }
+  return CallArgument.newBytes(
+    convertArgument(functionName, functionAbi, argument, position, genericTypeParams).bcsToBytes(),
+  );
+}
+
 /**
  * Converts a non-BCS encoded argument into BCS encoded, if necessary.
  * This function checks the provided argument against the expected parameter type and converts it accordingly.
@@ -369,6 +423,13 @@ function parseArg(
       }
     }
 
+    if (isString(arg)) {
+      // In a web env, arguments are passing as strings
+      if (arg.startsWith("[")) {
+        return checkOrConvertArgument(JSON.parse(arg), param, position, genericTypeParams);
+      }
+    }
+
     // TODO: Support Uint16Array, Uint32Array, BigUint64Array?
 
     if (Array.isArray(arg)) {

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -29,6 +29,7 @@ import { normalizeBundle } from "../../utils/normalizeBundle";
 import {
   AccountAuthenticator,
   AccountAuthenticatorEd25519,
+  AccountAuthenticatorMultiEd25519,
   AccountAuthenticatorMultiKey,
   AccountAuthenticatorNoAccountAuthenticator,
   AccountAuthenticatorSingleKey,
@@ -38,6 +39,7 @@ import {
   TransactionAuthenticatorEd25519,
   TransactionAuthenticatorFeePayer,
   TransactionAuthenticatorMultiAgent,
+  TransactionAuthenticatorMultiEd25519,
   TransactionAuthenticatorSingleSender,
 } from "../authenticator/transaction";
 import {
@@ -77,9 +79,10 @@ import {
 } from "../types";
 import { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardizeTypeTags } from "./remoteAbi";
 import { memoizeAsync } from "../../utils/memoize";
-import { getFunctionParts, isScriptDataInput } from "./helpers";
+import { isScriptDataInput } from "./helpers";
 import { SimpleTransaction } from "../instances/simpleTransaction";
 import { MultiAgentTransaction } from "../instances/multiAgentTransaction";
+import { getFunctionParts } from "../../utils/helpers";
 
 /**
  * Builds a transaction payload based on the provided arguments and returns a transaction payload.
@@ -699,6 +702,11 @@ export function generateSignedTransaction(args: InputSubmitTransactionData): Uin
       senderAuthenticator.public_key,
       senderAuthenticator.signature,
     );
+  } else if (senderAuthenticator instanceof AccountAuthenticatorMultiEd25519) {
+    txnAuthenticator = new TransactionAuthenticatorMultiEd25519(
+      senderAuthenticator.public_key,
+      senderAuthenticator.signature,
+    );
   } else {
     txnAuthenticator = new TransactionAuthenticatorSingleSender(senderAuthenticator);
   }

package/src/transactions/types.ts

@@ -1,6 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+import { CallArgument } from "@aptos-labs/script-composer-pack";
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveOption, MoveString, MoveVector } from "../bcs/serializable/moveStructs";
 import { Bool, U128, U16, U256, U32, U64, U8 } from "../bcs/serializable/movePrimitives";
@@ -192,6 +193,16 @@ export type InputMultiSigDataWithABI = {
  * @category Transactions
  */
 export type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & { aptosConfig: AptosConfig };
+
+/**
+ * The data needed to generate a batched function payload
+ */
+export type InputBatchedFunctionData = {
+  function: MoveFunctionId;
+  typeArguments?: Array<TypeArgument>;
+  functionArguments: Array<EntryFunctionArgumentTypes | CallArgument | SimpleEntryFunctionArgumentTypes>;
+};
+
 /**
  * The data needed to generate a Multi Sig payload
  * @group Implementation

package/src/types/abstraction.ts

@@ -0,0 +1,6 @@
+/**
+ * The variant for the AbstractionAuthData enum.
+ */
+export enum AbstractionAuthDataVariant {
+  V1 = 0,
+}

package/src/types/codegen.yaml

@@ -1,6 +1,6 @@
 overwrite: true
 documents: src/internal/queries/**/*.graphql
-schema: https://api.mainnet.aptoslabs.com/v1/graphql
+schema: https://api.devnet.aptoslabs.com/v1/graphql
 generates:
   src/types/generated/types.ts:
     plugins: