@aptos-labs/ts-sdk 6.3.1 → 7.0.1

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -6,26 +6,25 @@
  * It holds different operations to generate a transaction payload, a raw transaction,
  * and a signed transaction that can be simulated, signed and submitted to chain.
  */
-import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
-import { AptosConfig } from "../../api/aptosConfig";
-import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core";
+import { sha3_256 as sha3Hash } from "@noble/hashes/sha3.js";
+import { AptosConfig } from "../../api/aptosConfig.js";
+import { MAX_U64_BIG_INT } from "../../bcs/consts.js";
+import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core/index.js";
 import {
   AnyPublicKey,
   AnySignature,
-  KeylessPublicKey,
-  KeylessSignature,
   Secp256k1PublicKey,
-  FederatedKeylessPublicKey,
   MultiKey,
   MultiKeySignature,
-} from "../../core/crypto";
-import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
-import { getInfo } from "../../internal/utils";
-import { getLedgerInfo } from "../../internal/general";
-import { getGasPriceEstimation } from "../../internal/transaction";
-import { NetworkToChainId } from "../../utils/apiEndpoints";
-import { MIN_MAX_GAS_AMOUNT } from "../../utils/const";
-import { normalizeBundle } from "../../utils/normalizeBundle";
+} from "../../core/crypto/index.js";
+import { AnyPublicKeyVariant } from "../../types/index.js";
+import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519.js";
+import { getInfo } from "../../internal/utils/index.js";
+import { getLedgerInfo } from "../../internal/general.js";
+import { getGasPriceEstimation } from "../../internal/transaction.js";
+import { NetworkToChainId } from "../../utils/apiEndpoints.js";
+import { MIN_ENCRYPTED_TXN_GAS_UNIT_PRICE, MIN_MAX_GAS_AMOUNT, TEXT_ENCODER } from "../../utils/const.js";
+import { normalizeBundle } from "../../utils/normalizeBundle.js";
 import {
   AccountAuthenticator,
   AccountAuthenticatorEd25519,
@@ -33,7 +32,7 @@ import {
   AccountAuthenticatorMultiKey,
   AccountAuthenticatorNoAccountAuthenticator,
   AccountAuthenticatorSingleKey,
-} from "../authenticator/account";
+} from "../authenticator/account.js";
 import {
   TransactionAuthenticator,
   TransactionAuthenticatorEd25519,
@@ -41,7 +40,7 @@ import {
   TransactionAuthenticatorMultiAgent,
   TransactionAuthenticatorMultiEd25519,
   TransactionAuthenticatorSingleSender,
-} from "../authenticator/transaction";
+} from "../authenticator/transaction.js";
 import {
   ChainId,
   EntryFunction,
@@ -55,8 +54,8 @@ import {
   TransactionPayloadEntryFunction,
   TransactionPayloadMultiSig,
   TransactionPayloadScript,
-} from "../instances";
-import { SignedTransaction } from "../instances/signedTransaction";
+} from "../instances/index.js";
+import { SignedTransaction } from "../instances/signedTransaction.js";
 import {
   AnyRawTransaction,
   AnyTransactionPayloadInstance,
@@ -77,13 +76,13 @@ import {
   InputViewFunctionDataWithRemoteABI,
   InputViewFunctionDataWithABI,
   FunctionABI,
-} from "../types";
-import { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardizeTypeTags } from "./remoteAbi";
-import { memoizeAsync } from "../../utils/memoize";
-import { isScriptDataInput } from "./helpers";
-import { SimpleTransaction } from "../instances/simpleTransaction";
-import { MultiAgentTransaction } from "../instances/multiAgentTransaction";
-import { getFunctionParts } from "../../utils/helpers";
+} from "../types.js";
+import { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardizeTypeTags } from "./remoteAbi.js";
+import { memoizeAsync } from "../../utils/memoize.js";
+import { isScriptDataInput } from "./helpers.js";
+import { SimpleTransaction } from "../instances/simpleTransaction.js";
+import { MultiAgentTransaction } from "../instances/multiAgentTransaction.js";
+import { getFunctionParts } from "../../utils/helpers.js";
 import {
   TransactionExecutable,
   TransactionExecutableEmpty,
@@ -91,7 +90,8 @@ import {
   TransactionExecutableScript,
   TransactionExtraConfigV1,
   TransactionInnerPayloadV1,
-} from "../instances/transactionPayload";
+} from "../instances/transactionPayload.js";
+import { buildEncryptedPayload } from "./encryptPayload.js";
 
 /**
  * Builds a transaction payload based on the provided arguments and returns a transaction payload.
@@ -142,7 +142,15 @@ export async function generateTransactionPayload(
   args: InputGenerateTransactionPayloadDataWithRemoteABI,
 ): Promise<AnyTransactionPayloadInstance> {
   if (isScriptDataInput(args)) {
-    return generateTransactionPayloadScript(args);
+    const scriptPayload = generateTransactionPayloadScript(args);
+    // If multisigAddress is present, wrap the script in a multisig payload
+    if ("multisigAddress" in args) {
+      const multisigAddress = AccountAddress.from(args.multisigAddress);
+      return new TransactionPayloadMultiSig(
+        new MultiSig(multisigAddress, new MultiSigTransactionPayload(scriptPayload.script)),
+      );
+    }
+    return scriptPayload;
   }
   const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);
 
@@ -162,7 +170,10 @@ export async function generateTransactionPayload(
 
 /**
  * Generates a transaction payload using the provided ABI and function details.
- * This function helps create a properly structured transaction payload for executing a specific function on a module.
+ * This function is synchronous and works offline with pre-fetched ABIs (no network calls).
+ * Does NOT support plain object struct/enum arguments. For struct/enum arguments, encode them first
+ * using StructEnumArgumentParser.encodeStructArgument() or encodeEnumArgument(), then pass the
+ * encoded MoveStructArgument or MoveEnumArgument instances to functionArguments.
  *
  * @param args - The input data required to generate the transaction payload.
  * @param args.abi - The ABI of the function to be executed.
@@ -279,8 +290,8 @@ export async function generateViewFunctionPayload(args: InputViewFunctionDataWit
 
 /**
  * Generates a payload for a view function call using the provided ABI and arguments.
- * This function ensures that the type arguments and function arguments are correctly formatted
- * and match the expected counts as defined in the ABI.
+ * This function is synchronous and works offline with pre-fetched ABIs (no network calls).
+ * Does NOT support struct/enum arguments.
  *
  * @param args - The input data for generating the view function payload.
  * @param args.abi - The ABI of the function to be called.
@@ -364,8 +375,13 @@ export async function generateRawTransaction(args: {
   payload: AnyTransactionPayloadInstance;
   options?: InputGenerateTransactionOptions;
   feePayerAddress?: AccountAddressInput;
+  /**
+   * When building an encrypted multi-agent transaction, secondary signer addresses (same order as
+   * `options.secondarySignerAuthenticationKeys`).
+   */
+  secondarySignerAddresses?: AccountAddressInput[];
 }): Promise<RawTransaction> {
-  const { aptosConfig, sender, payload, options, feePayerAddress } = args;
+  const { aptosConfig, sender, payload, options, feePayerAddress, secondarySignerAddresses } = args;
 
   if (options?.replayProtectionNonce !== undefined && options?.accountSequenceNumber !== undefined) {
     throw new Error("Cannot specify both replayProtectionNonce and accountSequenceNumber in options.");
@@ -393,9 +409,9 @@ export async function generateRawTransaction(args: {
         return options.accountSequenceNumber;
       }
       if (options?.replayProtectionNonce !== undefined) {
-        // If replay nonce is provided, use it as the sequence number
-        // This is an unused value, so it's specifically to show that the sequence number is not used
-        return 0xdeadbeefn;
+        // Orderless: chain uses sequence_number = u64::MAX and replay protection via
+        // extra_config.replay_protection_nonce (see RawTransaction::replay_protector in aptos-core).
+        return MAX_U64_BIG_INT;
       }
 
       return (await getInfo({ aptosConfig, accountAddress: sender })).sequence_number;
@@ -429,17 +445,36 @@ export async function generateRawTransaction(args: {
   const userMaxGas = options?.maxGasAmount
     ? BigInt(options.maxGasAmount)
     : BigInt(aptosConfig.getDefaultMaxGasAmount());
-  const { maxGasAmount, gasUnitPrice, expireTimestamp, replayProtectionNonce } = {
-    maxGasAmount: userMaxGas < BigInt(MIN_MAX_GAS_AMOUNT) ? BigInt(MIN_MAX_GAS_AMOUNT) : userMaxGas,
-    gasUnitPrice: options?.gasUnitPrice ?? BigInt(gasEstimate),
-    expireTimestamp:
-      options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1000) + aptosConfig.getDefaultTxnExpirySecFromNow()),
-    replayProtectionNonce: options?.replayProtectionNonce ? BigInt(options.replayProtectionNonce) : undefined,
-  };
-
-  // If we're using replay nonce, we must convert the original payload
-  let txnPayload = payload;
-  if (replayProtectionNonce !== undefined) {
+  const maxGasAmount = userMaxGas < BigInt(MIN_MAX_GAS_AMOUNT) ? BigInt(MIN_MAX_GAS_AMOUNT) : userMaxGas;
+  let gasUnitPrice = BigInt(options?.gasUnitPrice ?? gasEstimate);
+  if (options?.encrypted && gasUnitPrice < BigInt(MIN_ENCRYPTED_TXN_GAS_UNIT_PRICE)) {
+    if (options.gasUnitPrice !== undefined) {
+      // Caller explicitly set a price below the encrypted-transaction floor — warn so they know it was overridden.
+      console.warn(
+        `Encrypted transaction: gasUnitPrice ${gasUnitPrice} is below the minimum ${MIN_ENCRYPTED_TXN_GAS_UNIT_PRICE}; overriding to ${MIN_ENCRYPTED_TXN_GAS_UNIT_PRICE}.`,
+      );
+    }
+    gasUnitPrice = BigInt(MIN_ENCRYPTED_TXN_GAS_UNIT_PRICE);
+  }
+  const expireTimestamp =
+    options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1000) + aptosConfig.getDefaultTxnExpirySecFromNow());
+  const replayProtectionNonce =
+    options?.replayProtectionNonce !== undefined ? BigInt(options.replayProtectionNonce) : undefined;
+
+  // If encryption was requested, the encrypted payload carries its own extra_config (with the
+  // replay nonce). Otherwise the orderless flow wraps the payload in an inner V1.
+  let txnPayload: AnyTransactionPayloadInstance = payload;
+  if (options?.encrypted) {
+    txnPayload = await buildEncryptedPayload({
+      aptosConfig,
+      sender,
+      payload,
+      options,
+      feePayerAddress,
+      secondarySignerAddresses,
+      replayProtectionNonce,
+    });
+  } else if (replayProtectionNonce !== undefined) {
     txnPayload = convertPayloadToInnerPayload(payload, replayProtectionNonce);
   }
 
@@ -477,9 +512,10 @@ export function convertPayloadToInnerPayload(
       executable = new TransactionExecutableEmpty();
     } else if (innerPayload.transaction_payload instanceof EntryFunction) {
       executable = new TransactionExecutableEntryFunction(innerPayload.transaction_payload);
+    } else if (innerPayload.transaction_payload instanceof Script) {
+      executable = new TransactionExecutableScript(innerPayload.transaction_payload);
     } else {
-      // TODO For now, scripts are not supported in multi-sig transactions, so it's always entry function
-      throw new Error("Scripts are not supported in multi-sig transactions.");
+      throw new Error("Unsupported multisig transaction payload type");
     }
 
     return new TransactionInnerPayloadV1(
@@ -545,6 +581,7 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
     payload,
     options,
     feePayerAddress,
+    secondarySignerAddresses: "secondarySignerAddresses" in args ? args.secondarySignerAddresses : undefined,
   });
 
   // if multi agent transaction
@@ -577,10 +614,10 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
  * @group Implementation
  * @category Transactions
  */
-export function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array {
+export async function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Promise<Uint8Array> {
   const { signerPublicKey, transaction, secondarySignersPublicKeys, feePayerPublicKey } = args;
 
-  const accountAuthenticator = getAuthenticatorForSimulation(signerPublicKey);
+  const accountAuthenticator = await getAuthenticatorForSimulation(signerPublicKey);
 
   // fee payer transaction
   if (transaction.feePayerAddress) {
@@ -592,16 +629,18 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
     let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];
     if (transaction.secondarySignerAddresses) {
       if (secondarySignersPublicKeys) {
-        secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>
-          getAuthenticatorForSimulation(publicKey),
+        secondaryAccountAuthenticators = await Promise.all(
+          secondarySignersPublicKeys.map((publicKey) => getAuthenticatorForSimulation(publicKey)),
         );
       } else {
-        secondaryAccountAuthenticators = Array.from({ length: transaction.secondarySignerAddresses.length }, () =>
-          getAuthenticatorForSimulation(undefined),
+        secondaryAccountAuthenticators = await Promise.all(
+          Array.from({ length: transaction.secondarySignerAddresses.length }, () =>
+            getAuthenticatorForSimulation(undefined),
+          ),
         );
       }
     }
-    const feePayerAuthenticator = getAuthenticatorForSimulation(feePayerPublicKey);
+    const feePayerAuthenticator = await getAuthenticatorForSimulation(feePayerPublicKey);
 
     const transactionAuthenticator = new TransactionAuthenticatorFeePayer(
       accountAuthenticator,
@@ -625,12 +664,14 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
     let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];
 
     if (secondarySignersPublicKeys) {
-      secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>
-        getAuthenticatorForSimulation(publicKey),
+      secondaryAccountAuthenticators = await Promise.all(
+        secondarySignersPublicKeys.map((publicKey) => getAuthenticatorForSimulation(publicKey)),
       );
     } else {
-      secondaryAccountAuthenticators = Array.from({ length: transaction.secondarySignerAddresses.length }, () =>
-        getAuthenticatorForSimulation(undefined),
+      secondaryAccountAuthenticators = await Promise.all(
+        Array.from({ length: transaction.secondarySignerAddresses.length }, () =>
+          getAuthenticatorForSimulation(undefined),
+        ),
       );
     }
 
@@ -667,18 +708,23 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
  * @group Implementation
  * @category Transactions
  */
-export function getAuthenticatorForSimulation(publicKey?: PublicKey) {
+export async function getAuthenticatorForSimulation(publicKey?: PublicKey) {
   if (!publicKey) {
     return new AccountAuthenticatorNoAccountAuthenticator();
   }
 
   // Wrap the public key types below with AnyPublicKey as they are only support through single sender.
   // Learn more about AnyPublicKey here - https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-55.md
-  const convertToAnyPublicKey =
-    KeylessPublicKey.isInstance(publicKey) ||
-    FederatedKeylessPublicKey.isInstance(publicKey) ||
-    Secp256k1PublicKey.isInstance(publicKey);
-  const accountPublicKey = convertToAnyPublicKey ? new AnyPublicKey(publicKey) : publicKey;
+  // Detect keyless public keys by duck-typing to avoid importing poseidon-heavy modules
+  const detectKeylessVariant = (key: PublicKey): AnyPublicKeyVariant | undefined => {
+    if ("jwkAddress" in key && "keylessPublicKey" in key) return AnyPublicKeyVariant.FederatedKeyless;
+    if ("iss" in key && typeof key.iss === "string" && "idCommitment" in key) return AnyPublicKeyVariant.Keyless;
+    return undefined;
+  };
+  const keylessVariant = detectKeylessVariant(publicKey);
+  const convertToAnyPublicKey = keylessVariant !== undefined || Secp256k1PublicKey.isInstance(publicKey);
+  // Pass variant explicitly for keyless keys to avoid instanceof-based registry detection
+  const accountPublicKey = convertToAnyPublicKey ? new AnyPublicKey(publicKey, keylessVariant) : publicKey;
 
   // No need to for the signature to be matching in scheme. All that matters for simulations is that it's not valid
   const invalidSignature = new Ed25519Signature(new Uint8Array(64));
@@ -688,7 +734,12 @@ export function getAuthenticatorForSimulation(publicKey?: PublicKey) {
   }
 
   if (AnyPublicKey.isInstance(accountPublicKey)) {
-    if (KeylessPublicKey.isInstance(accountPublicKey.publicKey)) {
+    if (
+      accountPublicKey.variant === AnyPublicKeyVariant.Keyless ||
+      accountPublicKey.variant === AnyPublicKeyVariant.FederatedKeyless
+    ) {
+      // Dynamic import to avoid pulling poseidon-lite into the main bundle
+      const { KeylessSignature } = await import("../../core/crypto/keyless.js");
       return new AccountAuthenticatorSingleKey(
         accountPublicKey,
         new AnySignature(KeylessSignature.getSimulationSignature()),
@@ -698,15 +749,22 @@ export function getAuthenticatorForSimulation(publicKey?: PublicKey) {
   }
 
   if (MultiKey.isInstance(accountPublicKey)) {
+    let keylessSignatureModule: typeof import("../../core/crypto/keyless.js") | undefined;
     return new AccountAuthenticatorMultiKey(
       accountPublicKey,
       new MultiKeySignature({
-        signatures: accountPublicKey.publicKeys.map((pubKey) => {
-          if (KeylessPublicKey.isInstance(pubKey.publicKey) || FederatedKeylessPublicKey.isInstance(pubKey.publicKey)) {
-            return new AnySignature(KeylessSignature.getSimulationSignature());
-          }
-          return new AnySignature(invalidSignature);
-        }),
+        signatures: await Promise.all(
+          accountPublicKey.publicKeys.map(async (pubKey) => {
+            if (
+              pubKey.variant === AnyPublicKeyVariant.Keyless ||
+              pubKey.variant === AnyPublicKeyVariant.FederatedKeyless
+            ) {
+              keylessSignatureModule ??= await import("../../core/crypto/keyless.js");
+              return new AnySignature(keylessSignatureModule.KeylessSignature.getSimulationSignature());
+            }
+            return new AnySignature(invalidSignature);
+          }),
+        ),
         bitmap: accountPublicKey.createBitmap({
           bits: new Array(accountPublicKey.publicKeys.length).fill(0).map((_, i) => i),
         }),
@@ -789,7 +847,7 @@ export function generateSignedTransaction(args: InputSubmitTransactionData): Uin
 export function hashValues(input: (Uint8Array | string)[]): Uint8Array {
   const hash = sha3Hash.create();
   for (const item of input) {
-    hash.update(item);
+    hash.update(typeof item === "string" ? TEXT_ENCODER.encode(item) : item);
   }
   return hash.digest();
 }

package/src/transactions/typeTag/index.ts

@@ -1,11 +1,11 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Deserializer } from "../../bcs/deserializer";
-import { Serializable, Serializer } from "../../bcs/serializer";
-import { AccountAddress } from "../../core";
-import { Identifier } from "../instances/identifier";
-import { TypeTagVariants } from "../../types";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { AccountAddress } from "../../core/index.js";
+import { Identifier } from "../instances/identifier.js";
+import { TypeTagVariants } from "../../types/index.js";
 
 /**
  * Represents a type tag in the serialization framework, serving as a base class for various specific type tags.

package/src/transactions/typeTag/parser.ts

@@ -23,9 +23,9 @@ import {
   TypeTagI128,
   TypeTagI256,
   TypeTagVector,
-} from ".";
-import { AccountAddress } from "../../core";
-import { Identifier } from "../instances/identifier";
+} from "./index.js";
+import { AccountAddress } from "../../core/index.js";
+import { Identifier } from "../instances/identifier.js";
 
 /**
  * Determines if the provided string is a valid Move identifier, which can only contain alphanumeric characters and underscores.

package/src/transactions/types.ts

@@ -1,12 +1,26 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AptosConfig } from "../api/aptosConfig";
-import { MoveOption, MoveString, MoveVector } from "../bcs/serializable/moveStructs";
-import { Bool, I128, I16, I256, I32, I64, I8, U128, U16, U256, U32, U64, U8 } from "../bcs/serializable/movePrimitives";
-import { FixedBytes } from "../bcs/serializable/fixedBytes";
-import { AccountAddress, AccountAddressInput } from "../core";
-import { PublicKey } from "../core/crypto";
+import { AptosConfig } from "../api/aptosConfig.js";
+import { MoveOption, MoveString, MoveVector } from "../bcs/serializable/moveStructs.js";
+import {
+  Bool,
+  I128,
+  I16,
+  I256,
+  I32,
+  I64,
+  I8,
+  U128,
+  U16,
+  U256,
+  U32,
+  U64,
+  U8,
+} from "../bcs/serializable/movePrimitives.js";
+import { FixedBytes } from "../bcs/serializable/fixedBytes.js";
+import { AccountAddress, AccountAddressInput } from "../core/index.js";
+import { AccountPublicKey, PublicKey } from "../core/crypto/index.js";
 import {
   MultiAgentRawTransaction,
   FeePayerRawTransaction,
@@ -15,21 +29,25 @@ import {
   TransactionPayloadMultiSig,
   TransactionPayloadScript,
   TransactionInnerPayload,
-} from "./instances";
+  TransactionPayloadEncryptedPayload,
+} from "./instances/index.js";
 import {
   AnyNumber,
   HexInput,
   MoveFunctionGenericTypeParam,
   MoveFunctionId,
+  MoveModuleId,
   MoveStructId,
   MoveValue,
   TransactionSubmitter,
-} from "../types";
-import { TypeTag } from "./typeTag";
-import { AccountAuthenticator } from "./authenticator/account";
-import { SimpleTransaction } from "./instances/simpleTransaction";
-import { MultiAgentTransaction } from "./instances/multiAgentTransaction";
-import { Serialized } from "../bcs";
+} from "../types/index.js";
+import type { ClaimedEntryFunction } from "./instances/encryptedPayload.js";
+import { TypeTag } from "./typeTag/index.js";
+import { AccountAuthenticator } from "./authenticator/account.js";
+import { SimpleTransaction } from "./instances/simpleTransaction.js";
+import { MultiAgentTransaction } from "./instances/multiAgentTransaction.js";
+import { Serialized } from "../bcs/index.js";
+import type { MoveStructArgument, MoveEnumArgument } from "./transactionBuilder/structEnumParser.js";
 
 /**
  * Entry function arguments for building a raw transaction using remote ABI, supporting various data types including primitives and arrays.
@@ -70,6 +88,8 @@ export type EntryFunctionArgumentTypes =
   | MoveVector<EntryFunctionArgumentTypes>
   | MoveOption<EntryFunctionArgumentTypes>
   | MoveString
+  | MoveStructArgument
+  | MoveEnumArgument
   | FixedBytes;
 
 /**
@@ -144,6 +164,49 @@ export type InputGenerateTransactionOptions =
   | InputGenerateSequenceNumberTransactionOptions
   | InputGenerateOrderlessTransactionOptions;
 
+/**
+ * Plain-object override for {@link ClaimedEntryFunction} when building encrypted transactions.
+ */
+export type InputClaimedEntryFunction = {
+  module: MoveModuleId;
+  functionName?: string;
+};
+
+/**
+ * Options for building encrypted transactions (combined with sequence- or orderless-specific fields).
+ */
+export type InputEncryptedTransactionBuildOptions = {
+  /**
+   * When true, the transaction payload will be encrypted before submission.
+   * Requires the node to support encrypted transactions (encryption key present in ledger info).
+   */
+  encrypted?: boolean;
+  /**
+   * Authentication key for the primary sender. Required when `encrypted` is true.
+   * Accept either an `AccountPublicKey` (auth key is derived automatically via `.authKey()`) or a raw 32-byte hex
+   * string. Must match the on-chain authenticator identity (aptos-core `PayloadAssociatedData::V1.signer_auth_keys`).
+   */
+  authenticationKey?: HexInput | AccountPublicKey;
+  /**
+   * For encrypted **multi-agent** transactions: each secondary signer's authentication key, in the same order
+   * as `secondarySignerAddresses` on the transaction build input. Accepts `AccountPublicKey` or raw 32-byte hex.
+   */
+  secondarySignerAuthenticationKeys?: (HexInput | AccountPublicKey)[];
+  /**
+   * For encrypted **fee-payer** transactions: the fee payer's authentication key. Required when `encrypted` is true
+   * and `feePayerAddress` is set to a **non-zero** sponsor address. Appended **last** in AAD `signer_auth_keys`,
+   * matching aptos-core `TransactionAuthenticator::all_signer_auth_keys` (after sender and secondaries).
+   * Accepts `AccountPublicKey` or raw 32-byte hex.
+   */
+  feePayerAuthenticationKey?: HexInput | AccountPublicKey;
+  /**
+   * Overrides `claimed_entry_fun` for encrypted transactions when a fee payer is set, the payload is multisig, or the
+   * payload is `TransactionInnerPayload` with a multisig address in `TransactionExtraConfigV1`.
+   * Ignored for plain encrypted single-signer transactions (none of the above).
+   */
+  claimedEntryFunction?: ClaimedEntryFunction | InputClaimedEntryFunction;
+};
+
 /**
  * Input options for generating a transaction that requires an account sequence number, which is the default method.
  */
@@ -153,7 +216,7 @@ export type InputGenerateSequenceNumberTransactionOptions = {
   expireTimestamp?: number;
   accountSequenceNumber?: AnyNumber;
   replayProtectionNonce?: undefined;
-};
+} & InputEncryptedTransactionBuildOptions;
 
 /**
  * Input options for generating a transaction using the orderless method, which does not require an account sequence number.
@@ -164,7 +227,7 @@ export type InputGenerateOrderlessTransactionOptions = {
   expireTimestamp?: number;
   accountSequenceNumber?: undefined;
   replayProtectionNonce: AnyNumber;
-};
+} & InputEncryptedTransactionBuildOptions;
 
 /**
  * The transaction payload type generated from the `generateTransactionPayload()` function, which can be an entry function,
@@ -176,14 +239,19 @@ export type AnyTransactionPayloadInstance =
   | TransactionPayloadEntryFunction
   | TransactionPayloadScript
   | TransactionPayloadMultiSig
-  | TransactionInnerPayload;
+  | TransactionInnerPayload
+  | TransactionPayloadEncryptedPayload;
 
 /**
  * The data needed to generate a transaction payload for Entry Function, Script, or Multi Sig types.
  * @group Implementation
  * @category Transactions
  */
-export type InputGenerateTransactionPayloadData = InputEntryFunctionData | InputScriptData | InputMultiSigData;
+export type InputGenerateTransactionPayloadData =
+  | InputEntryFunctionData
+  | InputScriptData
+  | InputMultiSigData
+  | InputMultiSigScriptData;
 
 /**
  * The payload for generating a transaction, which can be either script data, entry function data with remote ABI, or
@@ -193,6 +261,7 @@ export type InputGenerateTransactionPayloadData = InputEntryFunctionData | Input
  */
 export type InputGenerateTransactionPayloadDataWithRemoteABI =
   | InputScriptData
+  | InputMultiSigScriptData
   | InputEntryFunctionDataWithRemoteABI
   | InputMultiSigDataWithRemoteABI;
 
@@ -222,6 +291,7 @@ export type InputGenerateTransactionPayloadDataWithABI = InputEntryFunctionDataW
  */
 export type InputEntryFunctionDataWithABI = Omit<InputEntryFunctionData, "abi"> & {
   abi: EntryFunctionABI;
+  aptosConfig?: AptosConfig;
 };
 
 /**
@@ -268,6 +338,15 @@ export type InputScriptData = {
   functionArguments: Array<ScriptFunctionArgumentTypes>;
 };
 
+/**
+ * The data needed to generate a Multi Sig payload with a Script.
+ * @group Implementation
+ * @category Transactions
+ */
+export type InputMultiSigScriptData = {
+  multisigAddress: AccountAddressInput;
+} & InputScriptData;
+
 /**
  * The data needed to generate a View Function payload.
  * @group Implementation
@@ -314,7 +393,10 @@ export type InputViewFunctionDataWithRemoteABI = InputViewFunctionData & { aptos
  * @group Implementation
  * @category Transactions
  */
-export type InputViewFunctionDataWithABI = InputViewFunctionData & { abi: ViewFunctionABI };
+export type InputViewFunctionDataWithABI = InputViewFunctionData & {
+  abi: ViewFunctionABI;
+  aptosConfig?: AptosConfig;
+};
 
 /**
  * Data needed for a generic function ABI, applicable to both view and entry functions.
@@ -409,7 +491,9 @@ export type AnyRawTransaction = SimpleTransaction | MultiAgentTransaction;
  */
 export type InputSimulateTransactionData = {
   /**
-   * The transaction to simulate, probably generated by `generateTransaction()`
+   * The transaction to simulate, probably generated by `generateTransaction()`.
+   * Encrypted payloads (`options.encrypted` when building) are not supported: simulation throws
+   * before the request is sent; simulate a plaintext build of the same entry function instead.
    * @group Implementation
    * @category Transactions
    */

package/src/types/ans.ts

@@ -1,4 +1,4 @@
-import { type GetANSNameResponse } from "./indexer";
+import { type GetANSNameResponse } from "./indexer.js";
 
 export type RawANSName = GetANSNameResponse[0];
 
@@ -45,9 +45,13 @@ export enum ExpirationStatus {
 
 export interface AnsName extends RawANSName {
   /**
-   * The domain name. ie "aptos.apt" would have a domain of "aptos"
+   * The domain name. ie "aptos.apt" would have a domain of "aptos".
+   *
+   * The indexer schema marks this field as nullable, so it is surfaced as
+   * `string | undefined` here rather than fabricating a placeholder when the
+   * indexer returns null. Callers should treat a missing `domain` as a bad row.
    */
-  domain: string;
+  domain?: string;
   /**
    * The subdomain name, if the name is a subdomain. ie "name.aptos.apt" would have a subdomain of "name"
    */
@@ -87,13 +91,17 @@ export interface AnsName extends RawANSName {
   registered_address?: string;
   /**
    * The token standard for the name. See {@link AnsTokenStandard} for more details.
+   *
+   * Nullable upstream — surfaced as optional instead of fabricating `"v2"`.
    */
-  token_standard: AnsTokenStandard;
+  token_standard?: AnsTokenStandard;
   /**
    * If the name is registered as a primary name for _any_ account. It is
    * possible to have multiple primary names returned in a single query.
+   *
+   * Nullable upstream — surfaced as optional instead of defaulting to `false`.
    */
-  is_primary: boolean;
+  is_primary?: boolean;
   /**
    * The address of the wallet that owns the name.
    */