@aptos-labs/ts-sdk 6.3.0 → 7.0.0

package/src/core/accountAddress.ts

@@ -1,12 +1,12 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
-import { Serializable, Serializer } from "../bcs/serializer";
-import { Deserializer } from "../bcs/deserializer";
-import { ParsingError, ParsingResult } from "./common";
-import { TransactionArgument } from "../transactions/instances/transactionArgument";
-import { HexInput, ScriptTransactionArgumentVariants } from "../types";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+import { Serializable, Serializer, serializeEntryFunctionBytesCompat } from "../bcs/serializer.js";
+import { Deserializer } from "../bcs/deserializer.js";
+import { ParsingError, ParsingResult } from "./common.js";
+import { TransactionArgument } from "../transactions/instances/transactionArgument.js";
+import { HexInput, ScriptTransactionArgumentVariants } from "../types/index.js";
 
 /**
  * Provides reasons for an address was invalid.
@@ -240,14 +240,14 @@ export class AccountAddress extends Serializable implements TransactionArgument
   /**
    * Serializes the current instance into a byte sequence suitable for entry functions.
    * This allows for the proper encoding of data when interacting with entry functions in the blockchain.
-   * Uses the optimized serializeAsBytes method to reduce allocations.
+   * Uses serializeAsBytes when available, with a fallback for older Serializer versions.
    *
    * @param serializer - The serializer instance used to convert the data into bytes.
    * @group Implementation
    * @category Serialization
    */
   serializeForEntryFunction(serializer: Serializer): void {
-    serializer.serializeAsBytes(this);
+    serializeEntryFunctionBytesCompat(serializer, this);
   }
 
   /**

package/src/core/authenticationKey.ts

@@ -1,13 +1,13 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
-import { AccountAddress } from "./accountAddress";
-import type { AccountPublicKey } from "./crypto";
-import { Hex } from "./hex";
-import { AuthenticationKeyScheme, HexInput } from "../types";
-import { Serializable, Serializer } from "../bcs/serializer";
-import { Deserializer } from "../bcs/deserializer";
+import { sha3_256 as sha3Hash } from "@noble/hashes/sha3.js";
+import { AccountAddress } from "./accountAddress.js";
+import type { AccountPublicKey } from "./crypto/index.js";
+import { Hex } from "./hex.js";
+import { AuthenticationKeyScheme, HexInput } from "../types/index.js";
+import { Serializable, Serializer } from "../bcs/serializer.js";
+import { Deserializer } from "../bcs/deserializer.js";
 
 /**
  * Represents an authentication key used for account management. Each account stores an authentication key that enables account
@@ -59,14 +59,14 @@ export class AuthenticationKey extends Serializable {
   }
 
   /**
-   * Serializes the fixed bytes data into a format suitable for transmission or storage.
+   * Serializes the authentication key as length-prefixed bytes (BCS `serde_bytes` encoding).
    *
    * @param serializer - The serializer instance used to perform the serialization.
    * @group Implementation
    * @category Serialization
    */
   serialize(serializer: Serializer): void {
-    serializer.serializeFixedBytes(this.data.toUint8Array());
+    serializer.serializeBytes(this.data.toUint8Array());
   }
 
   /**
@@ -77,10 +77,22 @@ export class AuthenticationKey extends Serializable {
    * @category Serialization
    */
   static deserialize(deserializer: Deserializer): AuthenticationKey {
-    const bytes = deserializer.deserializeFixedBytes(AuthenticationKey.LENGTH);
+    const bytes = deserializer.deserializeBytes();
+    if (bytes.length !== AuthenticationKey.LENGTH) {
+      throw new Error(`AuthenticationKey BCS must be ${AuthenticationKey.LENGTH} bytes, got ${bytes.length}`);
+    }
     return new AuthenticationKey({ data: bytes });
   }
 
+  /**
+   * Override `Serializable.toString` (which would return the length-prefixed BCS hex) so the public
+   * representation stays the underlying 32-byte hex address — what callers compare against
+   * (REST `authentication_key`, indexer GraphQL filters, on-chain account address derivation).
+   */
+  toString(): string {
+    return this.data.toString();
+  }
+
   /**
    * Convert the internal data representation to a Uint8Array.
    *

package/src/core/crypto/abstraction.ts

@@ -1,10 +1,10 @@
-import { Deserializer, Serializer } from "../../bcs";
-import { HexInput } from "../../types";
-import { AccountAddress } from "../accountAddress";
-import { AuthenticationKey } from "../authenticationKey";
-import { Hex } from "../hex";
-import { AccountPublicKey, VerifySignatureArgs, VerifySignatureAsyncArgs } from "./publicKey";
-import { Signature } from "./signature";
+import { Deserializer, Serializer } from "../../bcs/index.js";
+import { HexInput } from "../../types/index.js";
+import { AccountAddress } from "../accountAddress.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { Hex } from "../hex.js";
+import { AccountPublicKey, VerifySignatureArgs, VerifySignatureAsyncArgs } from "./publicKey.js";
+import { Signature } from "./signature.js";
 
 export class AbstractSignature extends Signature {
   readonly value: Uint8Array;

package/src/core/crypto/anyKeyRegistry.ts

@@ -0,0 +1,90 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Registry for AnyPublicKey and AnySignature variant handlers.
+ *
+ * This allows keyless (and future) variants to register themselves at runtime,
+ * so that singleKey.ts does not need a compile-time dependency on keyless/poseidon.
+ * When the keyless module is imported, it registers its deserializers and instanceof
+ * checkers here. If keyless is never imported, these variants remain unregistered
+ * and deserialization will throw a clear error.
+ */
+
+import type { Deserializer } from "../../bcs/deserializer.js";
+import type { PublicKey } from "./publicKey.js";
+import type { Signature } from "./signature.js";
+
+export type PublicKeyDeserializer = (deserializer: Deserializer) => PublicKey;
+export type SignatureDeserializer = (deserializer: Deserializer) => Signature;
+export type VariantDetector = (key: PublicKey) => number | undefined;
+export type SignatureVariantDetector = (sig: Signature) => number | undefined;
+
+const publicKeyDeserializers = new Map<number, PublicKeyDeserializer>();
+const signatureDeserializers = new Map<number, SignatureDeserializer>();
+const publicKeyVariantDetectors: VariantDetector[] = [];
+const signatureVariantDetectors: SignatureVariantDetector[] = [];
+
+/**
+ * Register a deserializer for a public key variant.
+ * Called by modules that define new AnyPublicKey variants (e.g., keyless).
+ */
+export function registerPublicKeyVariant(
+  variant: number,
+  deserializer: PublicKeyDeserializer,
+  detector: VariantDetector,
+): void {
+  publicKeyDeserializers.set(variant, deserializer);
+  publicKeyVariantDetectors.push(detector);
+}
+
+/**
+ * Register a deserializer for a signature variant.
+ * Called by modules that define new AnySignature variants (e.g., keyless).
+ */
+export function registerSignatureVariant(
+  variant: number,
+  deserializer: SignatureDeserializer,
+  detector: SignatureVariantDetector,
+): void {
+  signatureDeserializers.set(variant, deserializer);
+  signatureVariantDetectors.push(detector);
+}
+
+/**
+ * Look up a registered public key deserializer by variant index.
+ */
+export function getPublicKeyDeserializer(variant: number): PublicKeyDeserializer | undefined {
+  return publicKeyDeserializers.get(variant);
+}
+
+/**
+ * Look up a registered signature deserializer by variant index.
+ */
+export function getSignatureDeserializer(variant: number): SignatureDeserializer | undefined {
+  return signatureDeserializers.get(variant);
+}
+
+/**
+ * Detect the variant for a public key using registered detectors.
+ * Returns the variant number, or undefined if no detector matches.
+ */
+export function detectPublicKeyVariant(key: PublicKey): number | undefined {
+  for (const detector of publicKeyVariantDetectors) {
+    const variant = detector(key);
+    if (variant !== undefined) return variant;
+  }
+  return undefined;
+}
+
+/**
+ * Detect the variant for a signature using registered detectors.
+ * Returns the variant number, or undefined if no detector matches.
+ */
+export function detectSignatureVariant(sig: Signature): number | undefined {
+  for (const detector of signatureVariantDetectors) {
+    const variant = detector(sig);
+    if (variant !== undefined) return variant;
+  }
+  return undefined;
+}

package/src/core/crypto/deserializationUtils.ts

@@ -1,22 +1,14 @@
-import {
-  AnyPublicKey,
-  Ed25519PublicKey,
-  MultiKey,
-  KeylessPublicKey,
-  MultiEd25519PublicKey,
-  FederatedKeylessPublicKey,
-  Secp256k1PublicKey,
-  Signature,
-  PublicKey,
-  Ed25519Signature,
-  Secp256k1Signature,
-  KeylessSignature,
-  AnySignature,
-  MultiEd25519Signature,
-  MultiKeySignature,
-} from "..";
-import { Deserializer } from "../../bcs/deserializer";
-import { HexInput } from "../../types";
+import { AnyPublicKey, AnySignature } from "./singleKey.js";
+import { Ed25519PublicKey, Ed25519Signature } from "./ed25519.js";
+import { MultiKey, MultiKeySignature } from "./multiKey.js";
+import { KeylessPublicKey, KeylessSignature } from "./keyless.js";
+import { MultiEd25519PublicKey, MultiEd25519Signature } from "./multiEd25519.js";
+import { FederatedKeylessPublicKey } from "./federatedKeyless.js";
+import { Secp256k1PublicKey, Secp256k1Signature } from "./secp256k1.js";
+import { PublicKey } from "./publicKey.js";
+import { Signature } from "./signature.js";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { HexInput } from "../../types/index.js";
 
 const MULTIPLE_DESERIALIZATIONS_ERROR_MSG = "Multiple possible deserializations found";
 

package/src/core/crypto/ed25519.ts

@@ -1,17 +1,17 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { ed25519 } from "@noble/curves/ed25519";
-import { Deserializer } from "../../bcs/deserializer";
-import { Serializable, Serializer } from "../../bcs/serializer";
-import { AuthenticationKey } from "../authenticationKey";
-import { Hex } from "../hex";
-import { HexInput, SigningScheme as AuthenticationKeyScheme, PrivateKeyVariants } from "../../types";
-import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from "./hdKey";
-import { PrivateKey } from "./privateKey";
-import { AccountPublicKey, PublicKey, VerifySignatureArgs, VerifySignatureAsyncArgs } from "./publicKey";
-import { Signature } from "./signature";
-import { convertSigningMessage } from "./utils";
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializable, Serializer } from "../../bcs/serializer.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { Hex } from "../hex.js";
+import { HexInput, SigningScheme as AuthenticationKeyScheme, PrivateKeyVariants } from "../../types/index.js";
+import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from "./hdKey.js";
+import { PrivateKey } from "./privateKey.js";
+import { AccountPublicKey, PublicKey, VerifySignatureArgs, VerifySignatureAsyncArgs } from "./publicKey.js";
+import { Signature } from "./signature.js";
+import { convertSigningMessage } from "./utils.js";
 
 /**
  * L is the value that greater than or equal to will produce a non-canonical signature, and must be rejected
@@ -219,7 +219,16 @@ export class Ed25519PublicKey extends AccountPublicKey {
    * @category Serialization
    */
   static isInstance(publicKey: PublicKey): publicKey is Ed25519PublicKey {
-    return "key" in publicKey && (publicKey.key as any)?.data?.length === Ed25519PublicKey.LENGTH;
+    return (
+      "key" in publicKey &&
+      typeof publicKey.key === "object" &&
+      publicKey.key !== null &&
+      "data" in publicKey.key &&
+      typeof publicKey.key.data === "object" &&
+      publicKey.key.data !== null &&
+      "length" in publicKey.key.data &&
+      publicKey.key?.data?.length === Ed25519PublicKey.LENGTH
+    );
   }
 }
 
@@ -290,7 +299,7 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * @category Serialization
    */
   static generate(): Ed25519PrivateKey {
-    const keyPair = ed25519.utils.randomPrivateKey();
+    const keyPair = ed25519.utils.randomSecretKey();
     return new Ed25519PrivateKey(keyPair, false);
   }
 

package/src/core/crypto/encryption/ciphertext.ts

@@ -0,0 +1,210 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Ported from aptos-core/crates/aptos-batch-encryption/ts-batch-encrypt/src/ciphertext.ts.
+ * BCS layout must match the Rust types in aptos_batch_encryption::shared::ciphertext.
+ */
+
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { bls12_381 } from "@noble/curves/bls12-381.js";
+import type { Fp2 } from "@noble/curves/abstract/tower.js";
+import type { WeierstrassPoint } from "@noble/curves/abstract/weierstrass.js";
+import { Serializable, Serializer } from "../../../bcs/serializer.js";
+import { Deserializer } from "../../../bcs/deserializer.js";
+import { leBytesToBigint, bigintToLEBytesFr, fp12ToLEBytes } from "./fieldSerialization.js";
+import { bytesToG2, G2_SIZE, g2ToBytes } from "./curveSerialization.js";
+import {
+  getRandomFr,
+  hashG2Element,
+  hashToFr,
+  ID_HASH_DST,
+  OneTimePad,
+  SymmetricCiphertext,
+  SymmetricKey,
+} from "./symmetric.js";
+
+/**
+ * Corresponds to the Rust type `aptos_batch_encryption::shared::ciphertext::BIBECiphertext`.
+ */
+export class BIBECiphertext extends Serializable {
+  id: bigint;
+  ctG2: WeierstrassPoint<Fp2>[];
+  paddedKey: SymmetricKey;
+  symmetricCiphertext: SymmetricCiphertext;
+
+  constructor(
+    id: bigint,
+    ctG2: WeierstrassPoint<Fp2>[],
+    paddedKey: SymmetricKey,
+    symmetricCiphertext: SymmetricCiphertext,
+  ) {
+    super();
+    if (ctG2.length !== 3) {
+      throw new Error("Need 3 G2 points here");
+    }
+    this.id = id;
+    this.ctG2 = ctG2;
+    this.paddedKey = paddedKey;
+    this.symmetricCiphertext = symmetricCiphertext;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(bigintToLEBytesFr(this.id));
+    // BCS: single length prefix for all 3 G2 elements (matches arkworks-serde wrapper in Rust)
+    const ctG2Bytes = new Uint8Array(G2_SIZE * 3);
+    ctG2Bytes.set(g2ToBytes(this.ctG2[0]), 0);
+    ctG2Bytes.set(g2ToBytes(this.ctG2[1]), G2_SIZE);
+    ctG2Bytes.set(g2ToBytes(this.ctG2[2]), G2_SIZE * 2);
+    serializer.serializeBytes(ctG2Bytes);
+    this.paddedKey.serialize(serializer);
+    this.symmetricCiphertext.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): BIBECiphertext {
+    const id = leBytesToBigint(deserializer.deserializeBytes());
+    const ctG2Bytes = deserializer.deserializeBytes();
+    if (ctG2Bytes.length !== G2_SIZE * 3) {
+      throw new Error(`Expected ${G2_SIZE * 3} bytes for 3 G2 points, got ${ctG2Bytes.length}`);
+    }
+    const ctG2 = [
+      bytesToG2(ctG2Bytes.slice(0, G2_SIZE)),
+      bytesToG2(ctG2Bytes.slice(G2_SIZE, G2_SIZE * 2)),
+      bytesToG2(ctG2Bytes.slice(G2_SIZE * 2, G2_SIZE * 3)),
+    ];
+    const paddedKey = SymmetricKey.deserialize(deserializer);
+    const symmetricCiphertext = SymmetricCiphertext.deserialize(deserializer);
+    return new BIBECiphertext(id, ctG2, paddedKey, symmetricCiphertext);
+  }
+}
+
+/**
+ * Corresponds to the Rust type `aptos_batch_encryption::shared::ciphertext::Ciphertext`.
+ */
+export class Ciphertext extends Serializable {
+  vk: Uint8Array;
+  bibeCt: BIBECiphertext;
+  associatedDataBytes: Uint8Array;
+  signature: Uint8Array;
+
+  constructor(vk: Uint8Array, bibeCt: BIBECiphertext, associatedDataBytes: Uint8Array, signature: Uint8Array) {
+    super();
+    if (vk.length !== 32) {
+      throw new Error(`ed25519 public key must be 32 bytes, got ${vk.length}`);
+    }
+    if (signature.length !== 64) {
+      throw new Error(`ed25519 signature must be 64 bytes, got ${signature.length}`);
+    }
+    this.vk = vk;
+    this.bibeCt = bibeCt;
+    this.associatedDataBytes = associatedDataBytes;
+    this.signature = signature;
+  }
+
+  serialize(serializer: Serializer): void {
+    // Rust: ed25519 VKs serialized as variable bytes
+    serializer.serializeBytes(this.vk);
+    this.bibeCt.serialize(serializer);
+    serializer.serializeBytes(this.associatedDataBytes);
+    // Rust: signatures serialized as fixed bytes
+    serializer.serializeFixedBytes(this.signature);
+  }
+
+  static deserialize(deserializer: Deserializer): Ciphertext {
+    const vk = deserializer.deserializeBytes();
+    const bibeCt = BIBECiphertext.deserialize(deserializer);
+    const associatedDataBytes = deserializer.deserializeBytes();
+    const signature = deserializer.deserializeFixedBytes(64);
+    return new Ciphertext(vk, bibeCt, associatedDataBytes, signature);
+  }
+}
+
+/**
+ * Corresponds to the Rust type `aptos_batch_encryption::shared::encryption_key::EncryptionKey`.
+ *
+ * Deserialize from hex (API) -> bytes -> BCS -> EncryptionKey.
+ */
+export class EncryptionKey extends Serializable {
+  sigMpkG2: WeierstrassPoint<Fp2>;
+  tauG2: WeierstrassPoint<Fp2>;
+
+  constructor(sigMpkG2: WeierstrassPoint<Fp2>, tauG2: WeierstrassPoint<Fp2>) {
+    super();
+    this.sigMpkG2 = sigMpkG2;
+    this.tauG2 = tauG2;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(g2ToBytes(this.sigMpkG2));
+    serializer.serializeBytes(g2ToBytes(this.tauG2));
+  }
+
+  static deserialize(deserializer: Deserializer): EncryptionKey {
+    const sigMpkG2 = bytesToG2(deserializer.deserializeBytes());
+    const tauG2 = bytesToG2(deserializer.deserializeBytes());
+    return new EncryptionKey(sigMpkG2, tauG2);
+  }
+
+  private bibeEncrypt(plaintext: Serializable, id: bigint): BIBECiphertext {
+    const G2 = bls12_381.G2.Point;
+    const Gt = bls12_381.fields.Fp12;
+
+    const r = [getRandomFr(), getRandomFr()];
+    const hashedEncryptionKey = hashG2Element(this.sigMpkG2);
+
+    const ctG2 = [
+      G2.BASE.multiply(r[0]).add(this.sigMpkG2.multiply(r[1])),
+      G2.BASE.multiply(id).subtract(this.tauG2).multiply(r[0]),
+      G2.BASE.negate().multiply(r[1]),
+    ];
+
+    // Target group: multiplication instead of addition (contrast with arkworks).
+    // hashToCurve returns H2CPoint which is structurally compatible with WeierstrassPoint
+    // but TypeScript doesn't unify them, so we cast via unknown.
+    const g1Point = hashedEncryptionKey.multiply(r[1]) as unknown as WeierstrassPoint<bigint>;
+    const otpSourceGt = Gt.inv(bls12_381.pairing(g1Point, this.sigMpkG2));
+
+    const otpSourceBytes = fp12ToLEBytes(otpSourceGt);
+    const otp = OneTimePad.fromSourceBytes(otpSourceBytes);
+
+    const symmetricKey = new SymmetricKey();
+    const paddedKey = otp.padKey(symmetricKey);
+
+    const symmetricCiphertext = symmetricKey.encrypt(plaintext);
+
+    return new BIBECiphertext(id, ctG2, paddedKey, symmetricCiphertext);
+  }
+
+  /**
+   * Encrypts a plaintext with associated data, producing a `Ciphertext`.
+   * Matches Rust: Id::from_verifying_key_and_ad(vk, associated_data) then CTEncrypt.
+   * The ciphertext Id must equal hash(vk || BCS(associated_data)) with ID_HASH_DST so the node can verify.
+   */
+  encrypt(plaintext: Serializable, associatedData: Serializable): Ciphertext {
+    const secretKey = ed25519.utils.randomSecretKey();
+    const publicKey = ed25519.getPublicKey(secretKey);
+
+    // Serialize associated data first (Rust: bcs::to_bytes(associated_data))
+    const adSerializer = new Serializer();
+    associatedData.serialize(adSerializer);
+    const associatedDataBytes = adSerializer.toUint8Array();
+
+    // Id = hash(vk || BCS(associated_data)) with domain separator; must match Rust Id::from_verifying_key_and_ad
+    const hashPreimage = new Uint8Array(publicKey.length + associatedDataBytes.length);
+    hashPreimage.set(publicKey, 0);
+    hashPreimage.set(associatedDataBytes, publicKey.length);
+    const hashedId = hashToFr(hashPreimage, ID_HASH_DST);
+
+    const bibeCt = this.bibeEncrypt(plaintext, hashedId);
+
+    // to_sign = (bibe_ct, associated_data_bytes) in Rust; BCS tuple = first element then second
+    const toSignSerializer = new Serializer();
+    bibeCt.serialize(toSignSerializer);
+    toSignSerializer.serializeBytes(associatedDataBytes);
+    const toSign = toSignSerializer.toUint8Array();
+
+    const signature = ed25519.sign(toSign, secretKey);
+
+    return new Ciphertext(publicKey, bibeCt, associatedDataBytes, signature);
+  }
+}

package/src/core/crypto/encryption/curveSerialization.ts

@@ -0,0 +1,46 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Fp2 } from "@noble/curves/abstract/tower.js";
+import type { WeierstrassPoint, WeierstrassPointCons } from "@noble/curves/abstract/weierstrass.js";
+import { bls12_381 } from "@noble/curves/bls12-381.js";
+
+export const G1_SIZE = 48;
+export const G2_SIZE = 96;
+
+/** Evaluates the short Weierstrass curve equation `x³ + a·x + b` at `x` over the field of `p`. */
+export function weierstrassEquation<T>(x: T, p: WeierstrassPointCons<T>): T {
+  const x2 = p.Fp.sqr(x);
+  const x3 = p.Fp.mul(x2, x);
+  return p.Fp.add(p.Fp.add(x3, p.Fp.mul(x, p.CURVE().a)), p.CURVE().b);
+}
+
+export function g1ToBytes(p: WeierstrassPoint<bigint>): Uint8Array {
+  return p.toBytes(true);
+}
+
+/**
+ * Compressed-G1 deserializer with prime-order subgroup check, matching aptos-core `ts-batch-encrypt`.
+ */
+export function bytesToG1(bytes: Uint8Array): WeierstrassPoint<bigint> {
+  const p = bls12_381.G1.Point.fromBytes(bytes);
+  if (!p.isTorsionFree()) {
+    throw new Error("Tried to deserialize invalid group element: not torsion free");
+  }
+  return p;
+}
+
+export function g2ToBytes(p: WeierstrassPoint<Fp2>): Uint8Array {
+  return p.toBytes(true);
+}
+
+/**
+ * Compressed-G2 deserializer with prime-order subgroup check, matching aptos-core `ts-batch-encrypt`.
+ */
+export function bytesToG2(bytes: Uint8Array): WeierstrassPoint<Fp2> {
+  const p = bls12_381.G2.Point.fromBytes(bytes);
+  if (!p.isTorsionFree()) {
+    throw new Error("Tried to deserialize invalid group element: not torsion free");
+  }
+  return p;
+}

package/src/core/crypto/encryption/fieldSerialization.ts

@@ -0,0 +1,82 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Fp2, Fp6, Fp12 } from "@noble/curves/abstract/tower.js";
+
+const BIGINT_SIZE = 48;
+const FP2_SIZE = 2 * BIGINT_SIZE;
+const FP6_SIZE = 3 * FP2_SIZE;
+const FP12_SIZE = 2 * FP6_SIZE;
+
+export function bigintToLEBytesInternal(val: bigint, numBytes: number): Uint8Array {
+  const ret: number[] = [];
+  let v = val;
+  for (let i = 0; i < numBytes; i++) {
+    ret.push(Number(BigInt.asUintN(8, v)));
+    v >>= 8n;
+  }
+  return Uint8Array.from(ret);
+}
+
+export function bigintToLEBytesFr(val: bigint): Uint8Array {
+  return bigintToLEBytesInternal(val, 32);
+}
+
+export function bigintToLEBytesFq(val: bigint): Uint8Array {
+  return bigintToLEBytesInternal(val, 48);
+}
+
+export function leBytesToBigint(bytes: Uint8Array): bigint {
+  let ret = 0n;
+  for (let i = 0; i < bytes.length; i++) {
+    ret += BigInt(bytes[i]) << (BigInt(i) * 8n);
+  }
+  return ret;
+}
+
+export function fp2ToLEBytes(val: Fp2): Uint8Array {
+  const ret = new Uint8Array(FP2_SIZE);
+  ret.set(bigintToLEBytesFq(val.c0));
+  ret.set(bigintToLEBytesFq(val.c1), BIGINT_SIZE);
+  return ret;
+}
+
+export function fp6ToLEBytes(val: Fp6): Uint8Array {
+  const ret = new Uint8Array(FP6_SIZE);
+  ret.set(fp2ToLEBytes(val.c0));
+  ret.set(fp2ToLEBytes(val.c1), FP2_SIZE);
+  ret.set(fp2ToLEBytes(val.c2), 2 * FP2_SIZE);
+  return ret;
+}
+
+export function fp12ToLEBytes(val: Fp12): Uint8Array {
+  const ret = new Uint8Array(FP12_SIZE);
+  ret.set(fp6ToLEBytes(val.c0));
+  ret.set(fp6ToLEBytes(val.c1), FP6_SIZE);
+  return ret;
+}
+
+export function leBytesToFp2(bytes: Uint8Array): Fp2 {
+  return {
+    c0: leBytesToBigint(bytes.slice(0, BIGINT_SIZE)),
+    c1: leBytesToBigint(bytes.slice(BIGINT_SIZE, FP2_SIZE)),
+  };
+}
+
+export function leBytesToFp6(bytes: Uint8Array): Fp6 {
+  return {
+    c0: leBytesToFp2(bytes.slice(0, FP2_SIZE)),
+    c1: leBytesToFp2(bytes.slice(FP2_SIZE, 2 * FP2_SIZE)),
+    c2: leBytesToFp2(bytes.slice(2 * FP2_SIZE, FP6_SIZE)),
+  };
+}
+
+export function leBytesToFp12(bytes: Uint8Array): Fp12 {
+  if (bytes.length !== FP12_SIZE) {
+    throw new Error(`Expected ${FP12_SIZE} bytes for Fp12, got ${bytes.length}`);
+  }
+  return {
+    c0: leBytesToFp6(bytes.slice(0, FP6_SIZE)),
+    c1: leBytesToFp6(bytes.slice(FP6_SIZE, FP12_SIZE)),
+  };
+}

package/src/core/crypto/encryption/index.ts

@@ -0,0 +1,14 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Batch encryption primitives for encrypted transaction payloads.
+ *
+ * Ported from aptos-core/crates/aptos-batch-encryption. Encrypt-only — decryption helpers are not implemented
+ * because the SDK never decrypts ciphertexts client-side. `bytesToG1`/`bytesToG2` enforce the prime-order
+ * subgroup check on deserialization, matching aptos-core `ts-batch-encrypt`.
+ *
+ * @module
+ */
+
+export { EncryptionKey } from "./ciphertext.js";