@aptos-labs/ts-sdk 6.3.0 → 7.0.0

package/src/transactions/instances/encryptedPayload.ts

@@ -0,0 +1,149 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { sha3_256 as sha3Hash } from "@noble/hashes/sha3.js";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { AccountAddress } from "../../core/index.js";
+import { AuthenticationKey } from "../../core/authenticationKey.js";
+import { Identifier } from "./identifier.js";
+import { ModuleId } from "./moduleId.js";
+import { EntryFunction, TransactionExecutable } from "./transactionPayload.js";
+
+/** 16-byte decryption nonce for encrypted payloads (aptos-core `DecryptionNonce`). */
+export const DECRYPTION_NONCE_LENGTH = 16;
+
+const DECRYPTED_PLAINTEXT_SALT = sha3Hash(new TextEncoder().encode("APTOS::DecryptedPlaintext"));
+
+/**
+ * Optional claim about the entry function inside an encrypted payload (`claimed_entry_fun` in aptos-core).
+ * Lets fee payers and multisig co-signers see module and optionally function name without decrypting.
+ *
+ * BCS: `module: ModuleId` then `function: Option<Identifier>`. The REST API renames the optional field to `name`.
+ */
+export class ClaimedEntryFunction extends Serializable {
+  public readonly moduleId: ModuleId;
+
+  /** BCS/Rust `function`; JSON API field is `name`. */
+  public readonly functionName?: Identifier;
+
+  constructor(moduleId: ModuleId, functionName?: Identifier) {
+    super();
+    this.moduleId = moduleId;
+    this.functionName = functionName;
+  }
+
+  serialize(serializer: Serializer): void {
+    this.moduleId.serialize(serializer);
+    serializer.serializeOption(this.functionName);
+  }
+
+  static deserialize(deserializer: Deserializer): ClaimedEntryFunction {
+    const moduleId = ModuleId.deserialize(deserializer);
+    const functionName = deserializer.deserializeOption(Identifier);
+    return new ClaimedEntryFunction(moduleId, functionName);
+  }
+
+  /**
+   * @param includeFunctionName - When false, only the module is claimed (`Option::None` for function on wire).
+   */
+  static fromEntryFunction(entry: EntryFunction, opts?: { includeFunctionName?: boolean }): ClaimedEntryFunction {
+    const includeFunctionName = opts?.includeFunctionName !== false;
+    return new ClaimedEntryFunction(entry.module_name, includeFunctionName ? entry.function_name : undefined);
+  }
+}
+
+/**
+ * BCS-serializable `DecryptedPlaintext`. Built client-side before encrypting; its BCS hash becomes `payload_hash`.
+ * Matches Rust: `DecryptedPlaintext { executable, decryption_nonce: [u8; 16] }`.
+ */
+export class DecryptedPlaintext extends Serializable {
+  executable: TransactionExecutable;
+
+  decryptionNonce: Uint8Array;
+
+  constructor(executable: TransactionExecutable, decryptionNonce: Uint8Array) {
+    super();
+    if (decryptionNonce.length !== DECRYPTION_NONCE_LENGTH) {
+      throw new Error(`decryptionNonce must be ${DECRYPTION_NONCE_LENGTH} bytes`);
+    }
+    this.executable = executable;
+    this.decryptionNonce = decryptionNonce;
+  }
+
+  serialize(serializer: Serializer): void {
+    this.executable.serialize(serializer);
+    serializer.serializeFixedBytes(this.decryptionNonce);
+  }
+
+  static deserialize(deserializer: Deserializer): DecryptedPlaintext {
+    const executable = TransactionExecutable.deserialize(deserializer);
+    const decryptionNonce = deserializer.deserializeFixedBytes(DECRYPTION_NONCE_LENGTH);
+    return new DecryptedPlaintext(executable, decryptionNonce);
+  }
+
+  /**
+   * Domain-separated BCS crypto hash (`BCSCryptoHash` in aptos-core):
+   * SHA3-256( SHA3-256("APTOS::DecryptedPlaintext") || BCS(self) ).
+   */
+  hash(): Uint8Array {
+    const h = sha3Hash.create();
+    h.update(DECRYPTED_PLAINTEXT_SALT);
+    h.update(this.bcsToBytes());
+    return h.digest();
+  }
+}
+
+/**
+ * One `(AccountAddress, AuthenticationKey)` entry in `PayloadAssociatedData::V1.signer_auth_keys` (aptos-core).
+ * @internal
+ */
+export type SignerAuthKeyPair = {
+  address: AccountAddress;
+  authenticationKey: AuthenticationKey;
+};
+
+const PAYLOAD_ASSOCIATED_DATA_V1 = 0;
+
+/**
+ * AAD for batch-encrypted transaction payloads. BCS matches Rust `PayloadAssociatedData::V1`:
+ * uleb128 variant | `sender` | `Vec<(AccountAddress, AuthenticationKey)>`.
+ */
+export class PayloadAssociatedData extends Serializable {
+  constructor(
+    public readonly sender: AccountAddress,
+    public readonly signerAuthKeys: readonly SignerAuthKeyPair[],
+  ) {
+    super();
+    if (signerAuthKeys.length === 0) {
+      throw new Error("PayloadAssociatedData requires at least one signer auth key pair");
+    }
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(PAYLOAD_ASSOCIATED_DATA_V1);
+    this.sender.serialize(serializer);
+    serializer.serializeU32AsUleb128(this.signerAuthKeys.length);
+    for (const { address, authenticationKey } of this.signerAuthKeys) {
+      address.serialize(serializer);
+      authenticationKey.serialize(serializer);
+    }
+  }
+
+  static deserialize(deserializer: Deserializer): PayloadAssociatedData {
+    const variant = deserializer.deserializeUleb128AsU32();
+    if (variant !== PAYLOAD_ASSOCIATED_DATA_V1) {
+      throw new Error(`Unknown PayloadAssociatedData variant: ${variant}`);
+    }
+    const sender = AccountAddress.deserialize(deserializer);
+    const len = deserializer.deserializeUleb128AsU32();
+    const signerAuthKeys: SignerAuthKeyPair[] = [];
+    for (let i = 0; i < len; i += 1) {
+      signerAuthKeys.push({
+        address: AccountAddress.deserialize(deserializer),
+        authenticationKey: AuthenticationKey.deserialize(deserializer),
+      });
+    }
+    return new PayloadAssociatedData(sender, signerAuthKeys);
+  }
+}

package/src/transactions/instances/identifier.ts

@@ -1,8 +1,8 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Deserializer } from "../../bcs/deserializer";
-import { Serializable, Serializer } from "../../bcs/serializer";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
 
 /**
  * Represents an Identifier that can be serialized and deserialized.

package/src/transactions/instances/index.ts

@@ -1,13 +1,14 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-export * from "./chainId";
-export * from "./identifier";
-export * from "./moduleId";
-export * from "./rawTransaction";
-export * from "./rotationProofChallenge";
-export * from "./signedTransaction";
-export * from "./transactionArgument";
-export * from "./transactionPayload";
-export * from "./simpleTransaction";
-export * from "./multiAgentTransaction";
+export * from "./chainId.js";
+export * from "./identifier.js";
+export * from "./moduleId.js";
+export * from "./rawTransaction.js";
+export * from "./rotationProofChallenge.js";
+export * from "./signedTransaction.js";
+export * from "./transactionArgument.js";
+export * from "./transactionPayload.js";
+export * from "./encryptedPayload.js";
+export * from "./simpleTransaction.js";
+export * from "./multiAgentTransaction.js";

package/src/transactions/instances/moduleId.ts

@@ -1,11 +1,11 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Serializable, Serializer } from "../../bcs/serializer";
-import { Deserializer } from "../../bcs/deserializer";
-import { AccountAddress } from "../../core";
-import { Identifier } from "./identifier";
-import { MoveModuleId } from "../../types";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { AccountAddress } from "../../core/index.js";
+import { Identifier } from "./identifier.js";
+import { MoveModuleId } from "../../types/index.js";
 
 /**
  * Represents a ModuleId that can be serialized and deserialized.

package/src/transactions/instances/multiAgentTransaction.ts

@@ -1,10 +1,10 @@
 // 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 { RawTransaction } from "./rawTransaction";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { AccountAddress } from "../../core/index.js";
+import { RawTransaction } from "./rawTransaction.js";
 
 /**
  * Represents a multi-agent transaction that can be serialized and deserialized.

package/src/transactions/instances/rawTransaction.ts

@@ -1,12 +1,12 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Deserializer } from "../../bcs/deserializer";
-import { Serializable, Serializer } from "../../bcs/serializer";
-import { ChainId } from "./chainId";
-import { AccountAddress } from "../../core";
-import { TransactionPayload } from "./transactionPayload";
-import { TransactionVariants } from "../../types";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { ChainId } from "./chainId.js";
+import { AccountAddress } from "../../core/index.js";
+import { TransactionPayload } from "./transactionPayload.js";
+import { TransactionVariants } from "../../types/index.js";
 
 /**
  * Represents a raw transaction that can be serialized and deserialized.

package/src/transactions/instances/rotationProofChallenge.ts

@@ -1,11 +1,11 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Serializer, Serializable } from "../../bcs/serializer";
-import { AccountAddress } from "../../core/accountAddress";
-import { AnyNumber } from "../../types";
-import { PublicKey } from "../../core/crypto";
-import { MoveString, MoveVector, U64, U8 } from "../../bcs";
+import { Serializer, Serializable } from "../../bcs/serializer.js";
+import { AccountAddress } from "../../core/accountAddress.js";
+import { AnyNumber } from "../../types/index.js";
+import { PublicKey } from "../../core/crypto/index.js";
+import { MoveString, MoveVector, U64, U8 } from "../../bcs/index.js";
 
 /**
  * Represents a challenge required for the account owner to sign in order to rotate the authentication key.

package/src/transactions/instances/signedTransaction.ts

@@ -1,10 +1,10 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { TransactionAuthenticator } from "../authenticator/transaction";
-import { Deserializer } from "../../bcs/deserializer";
-import { Serializable, Serializer } from "../../bcs/serializer";
-import { RawTransaction } from "./rawTransaction";
+import { TransactionAuthenticator } from "../authenticator/transaction.js";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { RawTransaction } from "./rawTransaction.js";
 
 /**
  * Represents a signed transaction that includes a raw transaction and an authenticator.

package/src/transactions/instances/simpleTransaction.ts

@@ -1,10 +1,10 @@
 // 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 { RawTransaction } from "./rawTransaction";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { AccountAddress } from "../../core/index.js";
+import { RawTransaction } from "./rawTransaction.js";
 
 /**
  * Represents a simple transaction type that can be submitted to the Aptos chain for execution.

package/src/transactions/instances/transactionArgument.ts

@@ -1,8 +1,8 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Serializer } from "../../bcs/serializer";
-import { Hex } from "../../core/hex";
+import { Serializer } from "../../bcs/serializer.js";
+import { Hex } from "../../core/hex.js";
 
 export interface TransactionArgument extends EntryFunctionArgument, ScriptFunctionArgument {}
 

package/src/transactions/instances/transactionPayload.ts

@@ -1,9 +1,9 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Deserializer } from "../../bcs/deserializer";
-import { Serializable, Serializer } from "../../bcs/serializer";
-import { EntryFunctionBytes } from "../../bcs/serializable/entryFunctionBytes";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { EntryFunctionBytes } from "../../bcs/serializable/entryFunctionBytes.js";
 import {
   Bool,
   U128,
@@ -18,22 +18,25 @@ import {
   I64,
   I128,
   I256,
-} from "../../bcs/serializable/movePrimitives";
-import { MoveVector, Serialized } from "../../bcs/serializable/moveStructs";
-import { AccountAddress } from "../../core";
-import { Identifier } from "./identifier";
-import { ModuleId } from "./moduleId";
-import type { EntryFunctionArgument, ScriptFunctionArgument, TransactionArgument } from "./transactionArgument";
+} from "../../bcs/serializable/movePrimitives.js";
+import { MoveVector, Serialized } from "../../bcs/serializable/moveStructs.js";
+import { AccountAddress } from "../../core/index.js";
+import { Ciphertext } from "../../core/crypto/encryption/ciphertext.js";
+import { ClaimedEntryFunction } from "./encryptedPayload.js";
+import { Identifier } from "./identifier.js";
+import { ModuleId } from "./moduleId.js";
+import type { EntryFunctionArgument, ScriptFunctionArgument, TransactionArgument } from "./transactionArgument.js";
 import {
   AnyNumber,
   MoveModuleId,
+  MultiSigTransactionPayloadVariants,
   ScriptTransactionArgumentVariants,
   TransactionExecutableVariants,
   TransactionExtraConfigVariants,
   TransactionInnerPayloadVariants,
   TransactionPayloadVariants,
-} from "../../types";
-import { TypeTag } from "../typeTag";
+} from "../../types/index.js";
+import { TypeTag } from "../typeTag/index.js";
 
 /**
  * Deserialize a Script Transaction Argument.
@@ -129,6 +132,8 @@ export abstract class TransactionPayload extends Serializable {
         return TransactionPayloadMultiSig.load(deserializer);
       case TransactionPayloadVariants.Payload:
         return TransactionInnerPayload.deserialize(deserializer);
+      case TransactionPayloadVariants.EncryptedPayload:
+        return TransactionPayloadEncryptedPayload.load(deserializer);
       default:
         throw new Error(`Unknown variant index for TransactionPayload: ${index}`);
     }
@@ -370,6 +375,80 @@ export class EntryFunction {
   }
 }
 
+/**
+ * Discriminants of Rust `EncryptedPayload`. Only `Encrypted` is produced or accepted client-side;
+ * `FailedDecryption` and `Decrypted` are listed for wire-format reference.
+ */
+enum EncryptedPayloadVariants {
+  Encrypted = 0,
+  FailedDecryption = 1,
+  Decrypted = 2,
+}
+
+/**
+ * `EncryptedPayload::Encrypted` as a `TransactionPayload`. BCS:
+ * variant tag (5) | inner tag (0) | Ciphertext | TransactionExtraConfig | 32-byte payload_hash | u64 epoch | Option<ClaimedEntryFunction>.
+ */
+export class TransactionPayloadEncryptedPayload extends TransactionPayload {
+  public readonly ciphertext: Ciphertext;
+
+  public readonly extraConfig: TransactionExtraConfig;
+
+  public readonly payloadHash: Uint8Array;
+
+  /** Epoch hint matching the node's per-epoch encryption key (see aptos-core `EncryptedInner`). */
+  public readonly encryptionEpoch: bigint;
+
+  public readonly claimedEntryFunction?: ClaimedEntryFunction;
+
+  constructor(
+    ciphertext: Ciphertext,
+    extraConfig: TransactionExtraConfig,
+    payloadHash: Uint8Array,
+    encryptionEpoch: bigint,
+    claimedEntryFunction?: ClaimedEntryFunction,
+  ) {
+    super();
+    if (payloadHash.length !== 32) {
+      throw new Error("payloadHash must be 32 bytes");
+    }
+    this.ciphertext = ciphertext;
+    this.extraConfig = extraConfig;
+    this.payloadHash = payloadHash;
+    this.encryptionEpoch = encryptionEpoch;
+    this.claimedEntryFunction = claimedEntryFunction;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionPayloadVariants.EncryptedPayload);
+    serializer.serializeU32AsUleb128(EncryptedPayloadVariants.Encrypted);
+    this.ciphertext.serialize(serializer);
+    this.extraConfig.serialize(serializer);
+    serializer.serializeFixedBytes(this.payloadHash);
+    serializer.serializeU64(this.encryptionEpoch);
+    serializer.serializeOption(this.claimedEntryFunction);
+  }
+
+  static load(deserializer: Deserializer): TransactionPayloadEncryptedPayload {
+    const variant = deserializer.deserializeUleb128AsU32();
+    if (variant !== EncryptedPayloadVariants.Encrypted) {
+      throw new Error(`Only EncryptedPayload::Encrypted (variant 0) is supported on the client, got ${variant}`);
+    }
+    const ciphertext = Ciphertext.deserialize(deserializer);
+    const extraConfig = TransactionExtraConfig.deserialize(deserializer);
+    const payloadHash = deserializer.deserializeFixedBytes(32);
+    const encryptionEpoch = deserializer.deserializeU64();
+    const claimedEntryFunction = deserializer.deserializeOption(ClaimedEntryFunction);
+    return new TransactionPayloadEncryptedPayload(
+      ciphertext,
+      extraConfig,
+      payloadHash,
+      encryptionEpoch,
+      claimedEntryFunction,
+    );
+  }
+}
+
 /**
  * Represents a Script that can be serialized and deserialized.
  * Scripts contain the Move bytecode payload that can be submitted to the Aptos chain for execution.
@@ -510,39 +589,42 @@ export class MultiSig {
  * @category Transactions
  */
 export class MultiSigTransactionPayload extends Serializable {
-  public readonly transaction_payload: EntryFunction;
+  public readonly transaction_payload: EntryFunction | Script;
 
   /**
    * Contains the payload to run a multi-sig account transaction.
    *
    * @param transaction_payload The payload of the multi-sig transaction.
-   * This can only be EntryFunction for now but,
-   * Script might be supported in the future.
+   * This can be an EntryFunction or a Script.
    * @group Implementation
    * @category Transactions
    */
-  constructor(transaction_payload: EntryFunction) {
+  constructor(transaction_payload: EntryFunction | Script) {
     super();
     this.transaction_payload = transaction_payload;
   }
 
   serialize(serializer: Serializer): void {
-    /**
-     * We can support multiple types of inner transaction payload in the future.
-     * For now, it's only EntryFunction but if we support more types,
-     * we need to serialize with the right enum values here
-     * @group Implementation
-     * @category Transactions
-     */
-    serializer.serializeU32AsUleb128(0);
+    if (this.transaction_payload instanceof EntryFunction) {
+      serializer.serializeU32AsUleb128(MultiSigTransactionPayloadVariants.EntryFunction);
+    } else if (this.transaction_payload instanceof Script) {
+      serializer.serializeU32AsUleb128(MultiSigTransactionPayloadVariants.Script);
+    } else {
+      throw new Error("Unsupported multisig transaction payload type");
+    }
     this.transaction_payload.serialize(serializer);
   }
 
   static deserialize(deserializer: Deserializer): MultiSigTransactionPayload {
-    // TODO: Support other types of payload beside EntryFunction.
-    // This is the enum value indicating which type of payload the multisig tx contains.
-    deserializer.deserializeUleb128AsU32();
-    return new MultiSigTransactionPayload(EntryFunction.deserialize(deserializer));
+    const variant = deserializer.deserializeUleb128AsU32();
+    switch (variant) {
+      case MultiSigTransactionPayloadVariants.EntryFunction:
+        return new MultiSigTransactionPayload(EntryFunction.deserialize(deserializer));
+      case MultiSigTransactionPayloadVariants.Script:
+        return new MultiSigTransactionPayload(Script.deserialize(deserializer));
+      default:
+        throw new Error(`Unknown MultisigTransactionPayload variant: ${variant}`);
+    }
   }
 }
 
@@ -605,6 +687,8 @@ export abstract class TransactionExecutable {
         return TransactionExecutableEntryFunction.load(deserializer);
       case TransactionExecutableVariants.Empty:
         return TransactionExecutableEmpty.load(deserializer);
+      case TransactionExecutableVariants.Encrypted:
+        return TransactionExecutableEncrypted.load(deserializer);
       default:
         throw new Error(`Unknown variant index for TransactionExecutable: ${index}`);
     }
@@ -659,7 +743,22 @@ export class TransactionExecutableEmpty extends TransactionExecutable {
   }
 }
 
-export abstract class TransactionExtraConfig {
+/**
+ * Server-side sentinel variant the fullnode places in a decrypted transaction.
+ * The SDK never constructs this; it exists only for deserialization completeness.
+ * @internal
+ */
+export class TransactionExecutableEncrypted extends TransactionExecutable {
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionExecutableVariants.Encrypted);
+  }
+
+  static load(_: Deserializer): TransactionExecutableEncrypted {
+    return new TransactionExecutableEncrypted();
+  }
+}
+
+export abstract class TransactionExtraConfig extends Serializable {
   abstract serialize(serializer: Serializer): void;
 
   static deserialize(deserializer: Deserializer): TransactionExtraConfig {

package/src/transactions/management/accountSequenceNumber.ts

@@ -25,10 +25,10 @@
  * @category Transactions
  */
 
-import { AptosConfig } from "../../api/aptosConfig";
-import { Account } from "../../account";
-import { getInfo } from "../../internal/account";
-import { nowInSeconds, sleep } from "../../utils/helpers";
+import { AptosConfig } from "../../api/aptosConfig.js";
+import { Account } from "../../account/index.js";
+import { getInfo } from "../../internal/account.js";
+import { nowInSeconds, sleep } from "../../utils/helpers.js";
 
 /**
  * Represents an account's sequence number management for transaction handling on the Aptos blockchain.
@@ -49,8 +49,7 @@ export class AccountSequenceNumber {
   readonly account: Account;
 
   // sequence number on chain
-  // TODO: Change to Uncommitted
-  lastUncommintedNumber: bigint | null = null;
+  lastUncommittedNumber: bigint | null = null;
 
   // local sequence number
   currentNumber: bigint | null = null;
@@ -118,15 +117,15 @@ export class AccountSequenceNumber {
     this.lock = true;
     let nextNumber = BigInt(0);
     try {
-      if (this.lastUncommintedNumber === null || this.currentNumber === null) {
+      if (this.lastUncommittedNumber === null || this.currentNumber === null) {
         await this.initialize();
       }
 
-      if (this.currentNumber! - this.lastUncommintedNumber! >= this.maximumInFlight) {
+      if (this.currentNumber! - this.lastUncommittedNumber! >= this.maximumInFlight) {
         await this.update();
 
         const startTime = nowInSeconds();
-        while (this.currentNumber! - this.lastUncommintedNumber! >= this.maximumInFlight) {
+        while (this.currentNumber! - this.lastUncommittedNumber! >= this.maximumInFlight) {
           await sleep(this.sleepTime);
           if (nowInSeconds() - startTime > this.maxWaitTime) {
             console.warn(
@@ -163,7 +162,7 @@ export class AccountSequenceNumber {
       accountAddress: this.account.accountAddress,
     });
     this.currentNumber = BigInt(sequenceNumber);
-    this.lastUncommintedNumber = BigInt(sequenceNumber);
+    this.lastUncommittedNumber = BigInt(sequenceNumber);
   }
 
   /**
@@ -178,8 +177,8 @@ export class AccountSequenceNumber {
       aptosConfig: this.aptosConfig,
       accountAddress: this.account.accountAddress,
     });
-    this.lastUncommintedNumber = BigInt(sequenceNumber);
-    return this.lastUncommintedNumber;
+    this.lastUncommittedNumber = BigInt(sequenceNumber);
+    return this.lastUncommittedNumber;
   }
 
   /**
@@ -191,7 +190,7 @@ export class AccountSequenceNumber {
    * @category Transactions
    */
   async synchronize(): Promise<void> {
-    if (this.lastUncommintedNumber === this.currentNumber) return;
+    if (this.lastUncommittedNumber === this.currentNumber) return;
 
     while (this.lock) {
       await sleep(this.sleepTime);
@@ -202,7 +201,7 @@ export class AccountSequenceNumber {
     try {
       await this.update();
       const startTime = nowInSeconds();
-      while (this.lastUncommintedNumber !== this.currentNumber) {
+      while (this.lastUncommittedNumber !== this.currentNumber) {
         if (nowInSeconds() - startTime > this.maxWaitTime) {
           console.warn(
             `Waited over 30 seconds for a transaction to commit, re-syncing ${this.account.accountAddress.toString()}`,

package/src/transactions/management/index.ts

@@ -1,2 +1,2 @@
-export * from "./accountSequenceNumber";
-export * from "./transactionWorker";
+export * from "./accountSequenceNumber.js";
+export * from "./transactionWorker.js";

package/src/transactions/management/transactionWorker.ts

@@ -1,13 +1,13 @@
-import EventEmitter from "eventemitter3";
-import { AptosConfig } from "../../api/aptosConfig";
-import { Account } from "../../account";
-import { waitForTransaction } from "../../internal/transaction";
-import { generateTransaction, signAndSubmitTransaction } from "../../internal/transactionSubmission";
-import { PendingTransactionResponse, TransactionResponse } from "../../types";
-import { InputGenerateTransactionOptions, InputGenerateTransactionPayloadData } from "../types";
-import { AccountSequenceNumber } from "./accountSequenceNumber";
-import { AsyncQueue, AsyncQueueCancelledError } from "./asyncQueue";
-import { SimpleTransaction } from "../instances/simpleTransaction";
+import { EventEmitter } from "eventemitter3";
+import { AptosConfig } from "../../api/aptosConfig.js";
+import { Account } from "../../account/index.js";
+import { waitForTransaction } from "../../internal/transaction.js";
+import { generateTransaction, signAndSubmitTransaction } from "../../internal/transactionSubmission.js";
+import { PendingTransactionResponse, TransactionResponse } from "../../types/index.js";
+import { InputGenerateTransactionOptions, InputGenerateTransactionPayloadData } from "../types.js";
+import { AccountSequenceNumber } from "./accountSequenceNumber.js";
+import { AsyncQueue, AsyncQueueCancelledError } from "./asyncQueue.js";
+import { SimpleTransaction } from "../instances/simpleTransaction.js";
 
 /**
  * Maximum number of transactions to keep in the history arrays to prevent unbounded memory growth.