@aptos-labs/ts-sdk 6.3.1 → 7.0.1

package/src/core/crypto/ephemeral.ts

@@ -1,10 +1,10 @@
-import { Serializer, Deserializer } from "../../bcs";
-import { EphemeralPublicKeyVariant, EphemeralSignatureVariant, HexInput } from "../../types";
-import { PublicKey } from "./publicKey";
-import { Signature } from "./signature";
-import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { Hex } from "../hex";
-import { AptosConfig } from "../../api";
+import { Serializer, Deserializer } from "../../bcs/index.js";
+import { EphemeralPublicKeyVariant, EphemeralSignatureVariant, HexInput } from "../../types/index.js";
+import { PublicKey } from "./publicKey.js";
+import { Signature } from "./signature.js";
+import { Ed25519PublicKey, Ed25519Signature } from "./ed25519.js";
+import { Hex } from "../hex.js";
+import { AptosConfig } from "../../api/aptosConfig.js";
 
 /**
  * Represents ephemeral public keys for Aptos Keyless accounts.

package/src/core/crypto/federatedKeyless.ts

@@ -1,11 +1,11 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AccountPublicKey, PublicKey } from "./publicKey";
-import { Deserializer, Serializer } from "../../bcs";
-import { HexInput, AnyPublicKeyVariant, SigningScheme } from "../../types";
-import { AuthenticationKey } from "../authenticationKey";
-import { AccountAddress, AccountAddressInput } from "../accountAddress";
+import { AccountPublicKey, PublicKey } from "./publicKey.js";
+import { Deserializer, Serializer } from "../../bcs/index.js";
+import { HexInput, AnyPublicKeyVariant, SigningScheme } from "../../types/index.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { AccountAddress, AccountAddressInput } from "../accountAddress.js";
 import {
   KeylessConfiguration,
   KeylessPublicKey,
@@ -13,9 +13,9 @@ import {
   MoveJWK,
   verifyKeylessSignature,
   verifyKeylessSignatureWithJwkAndConfig,
-} from "./keyless";
-import { AptosConfig } from "../../api";
-import { Signature } from "..";
+} from "./keyless.js";
+import { AptosConfig } from "../../api/aptosConfig.js";
+import { Signature } from "../index.js";
 
 /**
  * Represents the FederatedKeylessPublicKey public key

package/src/core/crypto/hdKey.ts

@@ -1,9 +1,10 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { hmac } from "@noble/hashes/hmac";
-import { sha512 } from "@noble/hashes/sha512";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha512 } from "@noble/hashes/sha2.js";
 import * as bip39 from "@scure/bip39";
+import { TEXT_ENCODER } from "../../utils/const.js";
 
 /**
  * Contains the derived cryptographic key as a Uint8Array.
@@ -85,8 +86,11 @@ export function isValidHardenedPath(path: string): boolean {
  * @group Implementation
  * @category Serialization
  */
+const toBytes = (input: Uint8Array | string): Uint8Array =>
+  typeof input === "string" ? TEXT_ENCODER.encode(input) : input;
+
 export const deriveKey = (hashSeed: Uint8Array | string, data: Uint8Array | string): DerivedKeys => {
-  const digest = hmac.create(sha512, hashSeed).update(data).digest();
+  const digest = hmac.create(sha512, toBytes(hashSeed)).update(toBytes(data)).digest();
   return {
     key: digest.slice(0, 32),
     chainCode: digest.slice(32),

package/src/core/crypto/index.ts

@@ -1,20 +1,27 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-export * from "./abstraction";
-export * from "./ed25519";
-export * from "./ephemeral";
-export * from "./federatedKeyless";
-export * from "./hdKey";
-export * from "./keyless";
-export * from "./multiEd25519";
-export * from "./multiKey";
-export * from "./poseidon";
-export * from "./privateKey";
-export * from "./publicKey";
-export * from "./secp256k1";
-export * from "./secp256r1";
-export * from "./signature";
-export * from "./singleKey";
-export * from "./types";
-export * from "./deserializationUtils";
+// Side-effect-free crypto exports (no poseidon-lite dependency)
+export * from "./abstraction.js";
+export * from "./ed25519.js";
+export * from "./multiEd25519.js";
+export * from "./multiKey.js";
+export * from "./privateKey.js";
+export * from "./publicKey.js";
+export * from "./secp256k1.js";
+export * from "./secp256r1.js";
+export * from "./signature.js";
+export * from "./singleKey.js";
+export * from "./types.js";
+export * from "./encryption/index.js";
+// NOTE: deserializationUtils is NOT re-exported here because it imports keyless types.
+// Import it directly from "./deserializationUtils.js" when needed.
+
+// NOTE: The following are intentionally NOT re-exported from this barrel
+// to keep the main import path free of poseidon-lite side effects.
+// Import them directly from their sub-paths:
+//   - "./ephemeral"         (EphemeralPublicKey, EphemeralSignature)
+//   - "./keyless"           (KeylessPublicKey, KeylessSignature, etc.)
+//   - "./federatedKeyless"  (FederatedKeylessPublicKey)
+//   - "./poseidon"          (poseidonHash, hashStrToField, etc.)
+//   - "./hdKey"             (deriveKey, etc.)

package/src/core/crypto/keyless.ts

@@ -2,11 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { JwtPayload, jwtDecode } from "jwt-decode";
-import { sha3_256 } from "@noble/hashes/sha3";
-import { AccountPublicKey, PublicKey } from "./publicKey";
-import { Signature } from "./signature";
-import { Deserializer, Serializable, Serializer } from "../../bcs";
-import { Hex, hexToAsciiString } from "../hex";
+import { sha3_256 } from "@noble/hashes/sha3.js";
+import { AccountPublicKey, PublicKey } from "./publicKey.js";
+import { Signature } from "./signature.js";
+import { Deserializer, Serializable, Serializer } from "../../bcs/index.js";
+import { Hex, hexToAsciiString } from "../hex.js";
 import {
   HexInput,
   EphemeralCertificateVariant,
@@ -15,31 +15,30 @@ import {
   ZkpVariant,
   LedgerVersionArg,
   MoveResource,
-} from "../../types";
-import { EphemeralPublicKey, EphemeralSignature } from "./ephemeral";
-import { bigIntToBytesLE, bytesToBigIntLE, hashStrToField, padAndPackBytesWithLen, poseidonHash } from "./poseidon";
-import { AuthenticationKey } from "../authenticationKey";
-import { Proof } from "./proof";
-import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
+} from "../../types/index.js";
+import { EphemeralPublicKey, EphemeralSignature } from "./ephemeral.js";
+import { bigIntToBytesLE, bytesToBigIntLE, hashStrToField, padAndPackBytesWithLen, poseidonHash } from "./poseidon.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { Proof } from "./proof.js";
+import { Ed25519PublicKey, Ed25519Signature } from "./ed25519.js";
 import {
   Groth16VerificationKeyResponse,
   KeylessConfigurationResponse,
   MoveAnyStruct,
   PatchedJWKsResponse,
-} from "../../types/keyless";
-import { AptosConfig } from "../../api/aptosConfig";
-import { getAptosFullNode } from "../../client";
-import { memoizeAsync } from "../../utils/memoize";
-import { AccountAddress, AccountAddressInput } from "../accountAddress";
-import { base64UrlToBytes, nowInSeconds } from "../../utils";
-import { KeylessError, KeylessErrorType } from "../../errors";
-import { bn254 } from "@noble/curves/bn254";
-import { bytesToNumberBE } from "@noble/curves/abstract/utils";
-import { FederatedKeylessPublicKey } from "./federatedKeyless";
-import { encode } from "js-base64";
-import { generateSigningMessage } from "../..";
-import { ProjPointType } from "@noble/curves/abstract/weierstrass";
-import { Fp2 } from "@noble/curves/abstract/tower";
+} from "../../types/keyless.js";
+import { AptosConfig } from "../../api/aptosConfig.js";
+import { getAptosFullNode } from "../../client/index.js";
+import { memoizeAsync } from "../../utils/memoize.js";
+import { AccountAddress, AccountAddressInput } from "../accountAddress.js";
+import { base64UrlEncode, base64UrlToBytes, nowInSeconds } from "../../utils/index.js";
+import { KeylessError, KeylessErrorType } from "../../errors/index.js";
+import { bn254 } from "@noble/curves/bn254.js";
+import { bytesToNumberBE } from "@noble/curves/utils.js";
+import { FederatedKeylessPublicKey } from "./federatedKeyless.js";
+import { generateSigningMessage } from "../../transactions/transactionBuilder/signingMessage.js";
+import { WeierstrassPoint } from "@noble/curves/abstract/weierstrass.js";
+import { Fp2 } from "@noble/curves/abstract/tower.js";
 
 /**
  * @group Implementation
@@ -493,7 +492,8 @@ function getPublicInputsHash(args: {
     fields.push(1n);
     fields.push(hashStrToField(proof.extraField, keylessConfig.maxExtraFieldBytes));
   }
-  fields.push(hashStrToField(`${encode(signature.jwtHeader, true)}.`, keylessConfig.maxJwtHeaderB64Bytes));
+  const jwtHeaderB64Url = base64UrlEncode(signature.jwtHeader);
+  fields.push(hashStrToField(`${jwtHeaderB64Url}.`, keylessConfig.maxJwtHeaderB64Bytes));
   fields.push(jwk.toScalar());
   if (!proof.overrideAudVal) {
     fields.push(hashStrToField("", MAX_AUD_VAL_BYTES));
@@ -767,14 +767,14 @@ class G1Bytes extends Serializable {
   // Convert the projective coordinates to strings
   toArray(): string[] {
     const point = this.toProjectivePoint();
-    return [point.x.toString(), point.y.toString(), point.pz.toString()];
+    return [point.x.toString(), point.y.toString(), point.Z.toString()];
   }
 
   /**
    * Converts the G1 bytes to a projective point.
    * @returns The projective point.
    */
-  toProjectivePoint(): ProjPointType<bigint> {
+  toProjectivePoint(): WeierstrassPoint<bigint> {
     const bytes = new Uint8Array(this.data);
     // Reverse the bytes to convert from little-endian to big-endian.
     bytes.reverse();
@@ -785,7 +785,7 @@ class G1Bytes extends Serializable {
     const y = Fp.sqrt(Fp.add(Fp.pow(x, 3n), G1Bytes.B));
     const negY = Fp.neg(y);
     const yToUse = y > negY === (yFlag === 1) ? y : negY;
-    return bn254.G1.ProjectivePoint.fromAffine({
+    return bn254.G1.Point.fromAffine({
       x,
       y: yToUse,
     });
@@ -851,13 +851,13 @@ class G2Bytes extends Serializable {
         point.y.c1.toString(),
       ], // y imaginary part
       [
-        point.pz.c0.toString(), // z real part
-        point.pz.c1.toString(),
+        point.Z.c0.toString(), // z real part
+        point.Z.c1.toString(),
       ], // z imaginary part
     ];
   }
 
-  toProjectivePoint(): ProjPointType<Fp2> {
+  toProjectivePoint(): WeierstrassPoint<Fp2> {
     const bytes = new Uint8Array(this.data);
     // Reverse the bytes to convert from little-endian to big-endian for each part of x.
     const x0 = bytes.slice(0, 32).reverse();
@@ -870,7 +870,7 @@ class G2Bytes extends Serializable {
     const negY = Fp2.neg(y);
     const isYGreaterThanNegY = y.c1 > negY.c1 || (y.c1 === negY.c1 && y.c0 > negY.c0);
     const yToUse = isYGreaterThanNegY === (yFlag === 1) ? y : negY;
-    return bn254.G2.ProjectivePoint.fromAffine({
+    return bn254.G2.Point.fromAffine({
       x,
       y: yToUse,
     });

package/src/core/crypto/keylessRegistration.ts

@@ -0,0 +1,34 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Registers keyless public key and signature variants with the AnyKey registry.
+ * This file is imported by modules that need keyless support, ensuring
+ * the keyless deserializers are available without requiring singleKey.ts
+ * to have a compile-time dependency on keyless/poseidon.
+ */
+
+import { AnyPublicKeyVariant, AnySignatureVariant } from "../../types/index.js";
+import { registerPublicKeyVariant, registerSignatureVariant } from "./anyKeyRegistry.js";
+import { KeylessPublicKey, KeylessSignature } from "./keyless.js";
+import { FederatedKeylessPublicKey } from "./federatedKeyless.js";
+import type { PublicKey } from "./publicKey.js";
+import type { Signature } from "./signature.js";
+
+registerPublicKeyVariant(
+  AnyPublicKeyVariant.Keyless,
+  (deserializer) => KeylessPublicKey.deserialize(deserializer),
+  (key: PublicKey) => (key instanceof KeylessPublicKey ? AnyPublicKeyVariant.Keyless : undefined),
+);
+
+registerPublicKeyVariant(
+  AnyPublicKeyVariant.FederatedKeyless,
+  (deserializer) => FederatedKeylessPublicKey.deserialize(deserializer),
+  (key: PublicKey) => (key instanceof FederatedKeylessPublicKey ? AnyPublicKeyVariant.FederatedKeyless : undefined),
+);
+
+registerSignatureVariant(
+  AnySignatureVariant.Keyless,
+  (deserializer) => KeylessSignature.deserialize(deserializer),
+  (sig: Signature) => (sig instanceof KeylessSignature ? AnySignatureVariant.Keyless : undefined),
+);

package/src/core/crypto/multiEd25519.ts

@@ -1,13 +1,13 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AptosConfig } from "../../api";
-import { Deserializer, Serializer } from "../../bcs";
-import { SigningScheme as AuthenticationKeyScheme, HexInput } from "../../types";
-import { AuthenticationKey } from "../authenticationKey";
-import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { AbstractMultiKey } from "./multiKey";
-import { Signature } from "./signature";
+import { AptosConfig } from "../../api/aptosConfig.js";
+import { Deserializer, Serializer } from "../../bcs/index.js";
+import { SigningScheme as AuthenticationKeyScheme, HexInput } from "../../types/index.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { Ed25519PublicKey, Ed25519Signature } from "./ed25519.js";
+import { AbstractMultiKey } from "./multiKey.js";
+import { Signature } from "./signature.js";
 
 /**
  * Represents the public key of a K-of-N Ed25519 multi-sig transaction.

package/src/core/crypto/multiKey.ts

@@ -1,11 +1,11 @@
-import { AnyPublicKeyVariant, SigningScheme as AuthenticationKeyScheme, HexInput } from "../../types";
-import { Deserializer } from "../../bcs/deserializer";
-import { Serializer } from "../../bcs/serializer";
-import { AuthenticationKey } from "../authenticationKey";
-import { AccountPublicKey, PublicKey } from "./publicKey";
-import { Signature } from "./signature";
-import { AnyPublicKey, AnySignature } from "./singleKey";
-import { AptosConfig } from "../../api";
+import { AnyPublicKeyVariant, SigningScheme as AuthenticationKeyScheme, HexInput } from "../../types/index.js";
+import { Deserializer } from "../../bcs/deserializer.js";
+import { Serializer } from "../../bcs/serializer.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { AccountPublicKey, PublicKey } from "./publicKey.js";
+import { Signature } from "./signature.js";
+import { AnyPublicKey, AnySignature } from "./singleKey.js";
+import { AptosConfig } from "../../api/aptosConfig.js";
 
 /**
  * Counts the number of set bits (1s) in a byte.

package/src/core/crypto/poseidon.ts

@@ -16,6 +16,7 @@ import {
   poseidon15,
   poseidon16,
 } from "poseidon-lite";
+import { TEXT_ENCODER } from "../../utils/const.js";
 
 const numInputsToPoseidonFunc = [
   poseidon1,
@@ -51,8 +52,7 @@ const MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALA
  * @category Serialization
  */
 export function hashStrToField(str: string, maxSizeBytes: number): bigint {
-  const textEncoder = new TextEncoder();
-  const strBytes = textEncoder.encode(str);
+  const strBytes = TEXT_ENCODER.encode(str);
   return hashBytesWithLen(strBytes, maxSizeBytes);
 }
 

package/src/core/crypto/privateKey.ts

@@ -1,8 +1,8 @@
-import { HexInput, PrivateKeyVariants } from "../../types";
-import { Hex } from "../hex";
-import { PublicKey } from "./publicKey";
-import { Signature } from "./signature";
-import { warnIfDevelopment } from "../../utils/helpers";
+import { HexInput, PrivateKeyVariants } from "../../types/index.js";
+import { Hex } from "../hex.js";
+import { PublicKey } from "./publicKey.js";
+import { Signature } from "./signature.js";
+import { warnIfDevelopment } from "../../utils/helpers.js";
 
 /**
  * Represents a private key used for signing messages and deriving the associated public key.

package/src/core/crypto/proof.ts

@@ -1,4 +1,4 @@
-import { Serializable } from "../../bcs";
+import { Serializable } from "../../bcs/index.js";
 
 /**
  * An abstract representation of a cryptographic proof associated with specific

package/src/core/crypto/publicKey.ts

@@ -1,9 +1,9 @@
-import { AptosConfig } from "../../api";
-import { Serializable } from "../../bcs";
-import { HexInput } from "../../types";
-import { AuthenticationKey } from "../authenticationKey";
-import { Hex } from "../hex";
-import { Signature } from "./signature";
+import { AptosConfig } from "../../api/aptosConfig.js";
+import { Serializable } from "../../bcs/index.js";
+import { HexInput } from "../../types/index.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { Hex } from "../hex.js";
+import { Signature } from "./signature.js";
 
 /**
  * Represents the arguments required to verify a digital signature.

package/src/core/crypto/secp256k1.ts

@@ -1,18 +1,18 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { sha3_256 } from "@noble/hashes/sha3";
-import { secp256k1 } from "@noble/curves/secp256k1";
+import { sha3_256 } from "@noble/hashes/sha3.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
 import { HDKey } from "@scure/bip32";
-import { Serializable, Deserializer, Serializer } from "../../bcs";
-import { Hex } from "../hex";
-import { HexInput, PrivateKeyVariants } from "../../types";
-import { isValidBIP44Path, mnemonicToSeed } from "./hdKey";
-import { PrivateKey } from "./privateKey";
-import { PublicKey } from "./publicKey";
-import { Signature } from "./signature";
-import { convertSigningMessage } from "./utils";
-import { AptosConfig } from "../../api";
+import { Serializable, Deserializer, Serializer } from "../../bcs/index.js";
+import { Hex } from "../hex.js";
+import { HexInput, PrivateKeyVariants } from "../../types/index.js";
+import { isValidBIP44Path, mnemonicToSeed } from "./hdKey.js";
+import { PrivateKey } from "./privateKey.js";
+import { PublicKey } from "./publicKey.js";
+import { Signature } from "./signature.js";
+import { convertSigningMessage } from "./utils.js";
+import { AptosConfig } from "../../api/aptosConfig.js";
 
 /**
  * Represents a Secp256k1 ECDSA public key.
@@ -52,8 +52,8 @@ export class Secp256k1PublicKey extends PublicKey {
     if (length === Secp256k1PublicKey.LENGTH) {
       this.key = hex;
     } else if (length === Secp256k1PublicKey.COMPRESSED_LENGTH) {
-      const point = secp256k1.ProjectivePoint.fromHex(hex.toUint8Array());
-      this.key = Hex.fromHexInput(point.toRawBytes(false));
+      const point = secp256k1.Point.fromBytes(hex.toUint8Array());
+      this.key = Hex.fromHexInput(point.toBytes(false));
     } else {
       throw new Error(
         `PublicKey length should be ${Secp256k1PublicKey.LENGTH} or ${Secp256k1PublicKey.COMPRESSED_LENGTH}, received ${length}`,
@@ -79,7 +79,7 @@ export class Secp256k1PublicKey extends PublicKey {
     const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
     const messageSha3Bytes = sha3_256(messageBytes);
     const signatureBytes = signature.toUint8Array();
-    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true });
+    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true, prehash: false });
   }
 
   /**
@@ -176,9 +176,16 @@ export class Secp256k1PublicKey extends PublicKey {
   static isInstance(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
     return (
       "key" in publicKey &&
-      (publicKey.key as any)?.data?.length === Secp256k1PublicKey.LENGTH &&
+      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 === Secp256k1PublicKey.LENGTH &&
       "keyType" in publicKey &&
-      (publicKey as any).keyType === "secp256k1"
+      typeof publicKey === "object" &&
+      publicKey.keyType === "secp256k1"
     );
   }
 }
@@ -242,7 +249,7 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
    * @category Serialization
    */
   static generate(): Secp256k1PrivateKey {
-    const hexInput = secp256k1.utils.randomPrivateKey();
+    const hexInput = secp256k1.utils.randomSecretKey();
     return new Secp256k1PrivateKey(hexInput, false);
   }
 
@@ -352,8 +359,8 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
     const messageToSign = convertSigningMessage(message);
     const messageBytes = Hex.fromHexInput(messageToSign);
     const messageHashBytes = sha3_256(messageBytes.toUint8Array());
-    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array(), { lowS: true });
-    return new Secp256k1Signature(signature.toCompactRawBytes());
+    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array(), { lowS: true, prehash: false });
+    return new Secp256k1Signature(signature);
   }
 
   /**

package/src/core/crypto/secp256r1.ts

@@ -1,20 +1,20 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { sha3_256 } from "@noble/hashes/sha3";
-import { p256 } from "@noble/curves/nist";
-import { Deserializer, Serializer } from "../../bcs";
-import { Hex } from "../hex";
+import { sha3_256 } from "@noble/hashes/sha3.js";
+import { p256 } from "@noble/curves/nist.js";
+import { Deserializer, Serializer } from "../../bcs/index.js";
+import { Hex } from "../hex.js";
 import {
   HexInput,
   PrivateKeyVariants,
   SigningScheme as AuthenticationKeyScheme,
   AnyPublicKeyVariant,
-} from "../../types";
-import { PublicKey, VerifySignatureAsyncArgs } from "./publicKey";
-import { PrivateKey } from "./privateKey";
-import { Signature } from "./signature";
-import { AuthenticationKey } from "../authenticationKey";
+} from "../../types/index.js";
+import { PublicKey, VerifySignatureAsyncArgs } from "./publicKey.js";
+import { PrivateKey } from "./privateKey.js";
+import { Signature } from "./signature.js";
+import { AuthenticationKey } from "../authenticationKey.js";
 
 /**
  * Represents a Secp256r1 ECDSA public key.
@@ -58,8 +58,8 @@ export class Secp256r1PublicKey extends PublicKey {
     }
 
     if (keyLength === Secp256r1PublicKey.COMPRESSED_LENGTH) {
-      const point = p256.ProjectivePoint.fromHex(hex.toUint8Array());
-      this.key = Hex.fromHexInput(point.toRawBytes(false));
+      const point = p256.Point.fromBytes(hex.toUint8Array());
+      this.key = Hex.fromHexInput(point.toBytes(false));
     } else {
       this.key = hex;
     }
@@ -119,7 +119,7 @@ export class Secp256r1PublicKey extends PublicKey {
     const sha3Message = sha3_256(msgHex);
     const rawSignature = signature.toUint8Array();
 
-    return p256.verify(rawSignature, sha3Message, this.toUint8Array());
+    return p256.verify(rawSignature, sha3Message, this.toUint8Array(), { prehash: false });
   }
 
   /**
@@ -188,9 +188,16 @@ export class Secp256r1PublicKey extends PublicKey {
   static isInstance(publicKey: PublicKey): publicKey is Secp256r1PublicKey {
     return (
       "key" in publicKey &&
-      (publicKey.key as any)?.data?.length === Secp256r1PublicKey.LENGTH &&
+      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 === Secp256r1PublicKey.LENGTH &&
       "keyType" in publicKey &&
-      (publicKey as any).keyType === "secp256r1"
+      typeof publicKey === "object" &&
+      publicKey.keyType === "secp256r1"
     );
   }
 
@@ -300,8 +307,8 @@ export class Secp256r1PrivateKey extends PrivateKey {
   sign(message: HexInput): Secp256r1Signature {
     const msgHex = Hex.fromHexInput(message);
     const sha3Message = sha3_256(msgHex.toUint8Array());
-    const signature = p256.sign(sha3Message, this.key.toUint8Array());
-    return new Secp256r1Signature(signature.toCompactRawBytes());
+    const signature = p256.sign(sha3Message, this.key.toUint8Array(), { prehash: false });
+    return new Secp256r1Signature(signature);
   }
 
   /**
@@ -337,7 +344,7 @@ export class Secp256r1PrivateKey extends PrivateKey {
    * @category Serialization
    */
   static generate(): Secp256r1PrivateKey {
-    const hexInput = p256.utils.randomPrivateKey();
+    const hexInput = p256.utils.randomSecretKey();
     return new Secp256r1PrivateKey(hexInput);
   }
 
@@ -442,8 +449,8 @@ export class Secp256r1Signature extends Signature {
     if (signatureLength !== Secp256r1Signature.LENGTH) {
       throw new Error(`Signature length should be ${Secp256r1Signature.LENGTH}, received ${signatureLength}`);
     }
-    const signature = p256.Signature.fromCompact(hex.toUint8Array()).normalizeS().toCompactRawBytes();
-    this.data = Hex.fromHexInput(signature);
+    const signature = p256.Signature.fromBytes(hex.toUint8Array());
+    this.data = Hex.fromHexInput(signature.toBytes());
   }
 
   /**

package/src/core/crypto/signature.ts

@@ -1,5 +1,5 @@
-import { Serializable } from "../../bcs";
-import { Hex } from "../hex";
+import { Serializable } from "../../bcs/index.js";
+import { Hex } from "../hex.js";
 
 /**
  * An abstract representation of a crypto signature,