@aptos-labs/ts-sdk 6.3.0 → 7.0.0

package/dist/core/crypto/poseidon.js

@@ -0,0 +1,196 @@
+import { poseidon1, poseidon2, poseidon3, poseidon4, poseidon5, poseidon6, poseidon7, poseidon8, poseidon9, poseidon10, poseidon11, poseidon12, poseidon13, poseidon14, poseidon15, poseidon16, } from "poseidon-lite";
+import { TEXT_ENCODER } from "../../utils/const.js";
+const numInputsToPoseidonFunc = [
+    poseidon1,
+    poseidon2,
+    poseidon3,
+    poseidon4,
+    poseidon5,
+    poseidon6,
+    poseidon7,
+    poseidon8,
+    poseidon9,
+    poseidon10,
+    poseidon11,
+    poseidon12,
+    poseidon13,
+    poseidon14,
+    poseidon15,
+    poseidon16,
+];
+const BYTES_PACKED_PER_SCALAR = 31;
+const MAX_NUM_INPUT_SCALARS = 16;
+const MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
+/**
+ * Hashes a string to a field element via Poseidon hashing.
+ * This function is useful for converting a string into a fixed-size hash that can be used in cryptographic applications.
+ *
+ * @param str - The string to be hashed.
+ * @param maxSizeBytes - The maximum size in bytes for the resulting hash.
+ * @returns bigint - The result of the hash.
+ * @group Implementation
+ * @category Serialization
+ */
+export function hashStrToField(str, maxSizeBytes) {
+    const strBytes = TEXT_ENCODER.encode(str);
+    return hashBytesWithLen(strBytes, maxSizeBytes);
+}
+/**
+ * Computes a Poseidon hash of the provided byte array, ensuring that the byte array does not exceed the specified maximum size.
+ * This function is useful for generating a hash from a byte array while enforcing size constraints.
+ *
+ * @param bytes - The byte array to be hashed.
+ * @param maxSizeBytes - The maximum allowed size for the byte array.
+ * @throws Error if the length of the inputted bytes exceeds the specified maximum size.
+ * @group Implementation
+ * @category Serialization
+ */
+function hashBytesWithLen(bytes, maxSizeBytes) {
+    if (bytes.length > maxSizeBytes) {
+        throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+    }
+    const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);
+    return poseidonHash(packed);
+}
+/**
+ * Pads the input byte array with zeros to a specified maximum size and then packs the bytes.
+ * This function ensures that the byte array does not exceed the specified maximum size, throwing an error if it does.
+ *
+ * @param bytes - The byte array to be padded and packed.
+ * @param maxSizeBytes - The maximum size in bytes that the input array can have.
+ * @throws Error if the input byte array exceeds the specified maximum size.
+ * @group Implementation
+ * @category Serialization
+ */
+function padAndPackBytesNoLen(bytes, maxSizeBytes) {
+    if (bytes.length > maxSizeBytes) {
+        throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+    }
+    const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);
+    return packBytes(paddedStrBytes);
+}
+/**
+ * Pads and packs the given byte array to a specified maximum size and appends its length.
+ * This function ensures that the byte array does not exceed the maximum size, throwing an error if it does.
+ * It is useful for preparing byte data for further processing or transmission by ensuring a consistent format.
+ *
+ * @param bytes - The byte array to be padded and packed.
+ * @param maxSizeBytes - The maximum allowed size for the byte array.
+ * @throws Error if the length of the input bytes exceeds the maximum size.
+ * @returns A new Uint8Array that contains the padded and packed bytes along with the length of the original byte array.
+ * @group Implementation
+ * @category Serialization
+ */
+export function padAndPackBytesWithLen(bytes, maxSizeBytes) {
+    if (bytes.length > maxSizeBytes) {
+        throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+    }
+    return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
+}
+/**
+ * Packs a Uint8Array into an array of BigInts, ensuring the input does not exceed the maximum allowed bytes.
+ * @param bytes - The Uint8Array to be packed.
+ * @throws {Error} Throws an error if the input exceeds the maximum number of bytes allowed.
+ * @group Implementation
+ * @category Serialization
+ */
+function packBytes(bytes) {
+    if (bytes.length > MAX_NUM_INPUT_BYTES) {
+        throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
+    }
+    return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
+}
+/**
+ * Splits a Uint8Array into smaller chunks of the specified size.
+ * This function is useful for processing large arrays in manageable segments.
+ *
+ * @param array - The Uint8Array to be split into chunks.
+ * @param chunkSize - The size of each chunk.
+ * @returns An array of Uint8Array chunks.
+ * @group Implementation
+ * @category Serialization
+ */
+function chunkUint8Array(array, chunkSize) {
+    const result = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+        result.push(array.subarray(i, i + chunkSize));
+    }
+    return result;
+}
+/**
+ * Converts a little-endian byte array into a BigInt.
+ * This function is useful for interpreting byte data as a numerical value in a way that respects the little-endian format.
+ *
+ * @param bytes - The byte array to convert.
+ * @returns The resulting BigInt representation of the byte array.
+ * @group Implementation
+ * @category Serialization
+ */
+export function bytesToBigIntLE(bytes) {
+    let result = BigInt(0);
+    for (let i = bytes.length - 1; i >= 0; i -= 1) {
+        result = (result << BigInt(8)) | BigInt(bytes[i]);
+    }
+    return result;
+}
+/**
+ * Converts a bigint value into a little-endian byte array of a specified length.
+ * This function is useful for representing large integers in a byte format, which is often required for cryptographic operations
+ * or binary data manipulation.
+ *
+ * @param value - The number to convert into bytes.
+ * @param length - The desired length of the resulting byte array.
+ * @returns A Uint8Array containing the little-endian representation of the bigint value.
+ * @group Implementation
+ * @category Serialization
+ */
+export function bigIntToBytesLE(value, length) {
+    let val = BigInt(value);
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i += 1) {
+        bytes[i] = Number(val & BigInt(0xff));
+        val >>= BigInt(8);
+    }
+    return bytes;
+}
+/**
+ * Pads the input Uint8Array with zeros to achieve the specified size.
+ * This function is useful for ensuring that a byte array meets a required length for further processing.
+ *
+ * @param inputArray - The Uint8Array to be padded.
+ * @param paddedSize - The desired size of the padded array, which must be greater than or equal to the input array size.
+ * @throws Error if paddedSize is less than the length of inputArray.
+ * @group Implementation
+ * @category Serialization
+ */
+function padUint8ArrayWithZeros(inputArray, paddedSize) {
+    if (paddedSize < inputArray.length) {
+        throw new Error("Padded size must be greater than or equal to the input array size.");
+    }
+    // Create a new Uint8Array with the padded size
+    const paddedArray = new Uint8Array(paddedSize);
+    // Copy the content of the input array to the new array
+    paddedArray.set(inputArray);
+    // Fill the remaining space with zeros
+    for (let i = inputArray.length; i < paddedSize; i += 1) {
+        paddedArray[i] = 0;
+    }
+    return paddedArray;
+}
+/**
+ * Hashes up to 16 scalar elements via the Poseidon hashing algorithm.
+ * Each element must be scalar fields of the BN254 elliptic curve group.
+ *
+ * @param inputs - An array of elements to be hashed, which can be of type number, bigint, or string.
+ * @returns bigint - The result of the hash.
+ * @throws Error - Throws an error if the input length exceeds the maximum allowed.
+ * @group Implementation
+ * @category Serialization
+ */
+export function poseidonHash(inputs) {
+    if (inputs.length > numInputsToPoseidonFunc.length) {
+        throw new Error(`Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`);
+    }
+    return numInputsToPoseidonFunc[inputs.length - 1](inputs);
+}
+//# sourceMappingURL=poseidon.js.map

package/dist/core/crypto/poseidon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseidon.js","sourceRoot":"","sources":["../../../src/core/crypto/poseidon.ts"],"names":[],"mappings":"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"}

package/dist/core/crypto/privateKey.d.ts

@@ -0,0 +1,64 @@
+import { HexInput, PrivateKeyVariants } from "../../types/index.js";
+import { Hex } from "../hex.js";
+import { PublicKey } from "./publicKey.js";
+import { Signature } from "./signature.js";
+/**
+ * Represents a private key used for signing messages and deriving the associated public key.
+ * @group Implementation
+ * @category Serialization
+ */
+export interface PrivateKey {
+    /**
+     * Sign the given message with the private key to create a signature.
+     * @param message - The message to be signed, provided in HexInput format.
+     * @returns A Signature object representing the signed message.
+     * @group Implementation
+     * @category Serialization
+     */
+    sign(message: HexInput): Signature;
+    /**
+     * Derive the public key associated with the private key.
+     * @group Implementation
+     * @category Serialization
+     */
+    publicKey(): PublicKey;
+    /**
+     * Get the private key in bytes (Uint8Array).
+     * @group Implementation
+     * @category Serialization
+     */
+    toUint8Array(): Uint8Array;
+}
+export declare class PrivateKey {
+    /**
+     * The AIP-80 compliant prefixes for each private key type. Append this to a private key's hex representation
+     * to get an AIP-80 compliant string.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     */
+    static readonly AIP80_PREFIXES: {
+        ed25519: string;
+        secp256k1: string;
+        secp256r1: string;
+    };
+    /**
+     * Format a HexInput to an AIP-80 compliant string.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
+     * @param privateKey - The HexString or Uint8Array format of the private key.
+     * @param privateKeyType - The private key type
+     */
+    static formatPrivateKey(privateKey: HexInput, type: PrivateKeyVariants): string;
+    /**
+     * Parse a HexInput that may be a HexString, Uint8Array, or a AIP-80 compliant string to a Hex instance.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
+     * @param value - A HexString, Uint8Array, or a AIP-80 compliant string.
+     * @param privateKeyType - The private key type
+     * @param strict - If true, the value MUST be compliant with AIP-80.
+     */
+    static parseHexInput(value: HexInput, type: PrivateKeyVariants, strict?: boolean): Hex;
+}
+//# sourceMappingURL=privateKey.d.ts.map

package/dist/core/crypto/privateKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privateKey.d.ts","sourceRoot":"","sources":["../../../src/core/crypto/privateKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,SAAS,CAAC;IAEnC;;;;OAIG;IACH,SAAS,IAAI,SAAS,CAAC;IAEvB;;;;OAIG;IACH,YAAY,IAAI,UAAU,CAAC;CAC5B;AAED,qBAAa,UAAU;IACrB;;;;;OAKG;IACH,gBAAuB,cAAc;;;;MAInC;IAEF;;;;;;;OAOG;WACW,gBAAgB,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,kBAAkB,GAAG,MAAM;IAYtF;;;;;;;;OAQG;WACW,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,GAAG;CAiC9F"}

package/dist/core/crypto/privateKey.js

@@ -0,0 +1,74 @@
+import { PrivateKeyVariants } from "../../types/index.js";
+import { Hex } from "../hex.js";
+import { warnIfDevelopment } from "../../utils/helpers.js";
+export class PrivateKey {
+    /**
+     * The AIP-80 compliant prefixes for each private key type. Append this to a private key's hex representation
+     * to get an AIP-80 compliant string.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     */
+    static AIP80_PREFIXES = {
+        [PrivateKeyVariants.Ed25519]: "ed25519-priv-",
+        [PrivateKeyVariants.Secp256k1]: "secp256k1-priv-",
+        [PrivateKeyVariants.Secp256r1]: "secp256r1-priv-",
+    };
+    /**
+     * Format a HexInput to an AIP-80 compliant string.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
+     * @param privateKey - The HexString or Uint8Array format of the private key.
+     * @param privateKeyType - The private key type
+     */
+    static formatPrivateKey(privateKey, type) {
+        const aip80Prefix = PrivateKey.AIP80_PREFIXES[type];
+        // Remove the prefix if it exists
+        let formattedPrivateKey = privateKey;
+        if (typeof formattedPrivateKey === "string" && formattedPrivateKey.startsWith(aip80Prefix)) {
+            formattedPrivateKey = formattedPrivateKey.split("-")[2];
+        }
+        return `${aip80Prefix}${Hex.fromHexInput(formattedPrivateKey).toString()}`;
+    }
+    /**
+     * Parse a HexInput that may be a HexString, Uint8Array, or a AIP-80 compliant string to a Hex instance.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
+     * @param value - A HexString, Uint8Array, or a AIP-80 compliant string.
+     * @param privateKeyType - The private key type
+     * @param strict - If true, the value MUST be compliant with AIP-80.
+     */
+    static parseHexInput(value, type, strict) {
+        let data;
+        const aip80Prefix = PrivateKey.AIP80_PREFIXES[type];
+        if (typeof value === "string") {
+            if (!strict && !value.startsWith(aip80Prefix)) {
+                // HexString input
+                data = Hex.fromHexInput(value);
+                // If the strictness is false, the user has opted into non-AIP-80 compliant private keys.
+                if (strict !== false) {
+                    warnIfDevelopment("[Aptos SDK] It is recommended that private keys are AIP-80 compliant (https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md). You can fix the private key by formatting it with `PrivateKey.formatPrivateKey(privateKey: string, type: 'ed25519' | 'secp256k1'): string`.");
+                }
+            }
+            else if (value.startsWith(aip80Prefix)) {
+                // AIP-80 Compliant String input
+                data = Hex.fromHexString(value.split("-")[2]);
+            }
+            else {
+                if (strict) {
+                    // The value does not start with the AIP-80 prefix, and strict is true.
+                    throw new Error("Invalid HexString input while parsing private key. Must AIP-80 compliant string.");
+                }
+                // This condition should never be reached.
+                throw new Error("Invalid HexString input while parsing private key.");
+            }
+        }
+        else {
+            // The value is an Uint8Array
+            data = Hex.fromHexInput(value);
+        }
+        return data;
+    }
+}
+//# sourceMappingURL=privateKey.js.map

package/dist/core/crypto/privateKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"privateKey.js","sourceRoot":"","sources":["../../../src/core/crypto/privateKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAGhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAgC3D,MAAM,OAAO,UAAU;IACrB;;;;;OAKG;IACI,MAAM,CAAU,cAAc,GAAG;QACtC,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,eAAe;QAC7C,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,iBAAiB;QACjD,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,iBAAiB;KAClD,CAAC;IAEF;;;;;;;OAOG;IACI,MAAM,CAAC,gBAAgB,CAAC,UAAoB,EAAE,IAAwB;QAC3E,MAAM,WAAW,GAAG,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAEpD,iCAAiC;QACjC,IAAI,mBAAmB,GAAG,UAAU,CAAC;QACrC,IAAI,OAAO,mBAAmB,KAAK,QAAQ,IAAI,mBAAmB,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;YAC3F,mBAAmB,GAAG,mBAAmB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,CAAC;QAED,OAAO,GAAG,WAAW,GAAG,GAAG,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC7E,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,aAAa,CAAC,KAAe,EAAE,IAAwB,EAAE,MAAgB;QACrF,IAAI,IAAS,CAAC;QAEd,MAAM,WAAW,GAAG,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QACpD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC9C,kBAAkB;gBAClB,IAAI,GAAG,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;gBAC/B,yFAAyF;gBACzF,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;oBACrB,iBAAiB,CACf,uRAAuR,CACxR,CAAC;gBACJ,CAAC;YACH,CAAC;iBAAM,IAAI,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;gBACzC,gCAAgC;gBAChC,IAAI,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAChD,CAAC;iBAAM,CAAC;gBACN,IAAI,MAAM,EAAE,CAAC;oBACX,uEAAuE;oBACvE,MAAM,IAAI,KAAK,CAAC,kFAAkF,CAAC,CAAC;gBACtG,CAAC;gBAED,0CAA0C;gBAC1C,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;YACxE,CAAC;QACH,CAAC;aAAM,CAAC;YACN,6BAA6B;YAC7B,IAAI,GAAG,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC"}

package/dist/core/crypto/proof.d.ts

@@ -0,0 +1,10 @@
+import { Serializable } from "../../bcs/index.js";
+/**
+ * An abstract representation of a cryptographic proof associated with specific
+ * zero-knowledge proof schemes, such as Groth16 and PLONK.
+ * @group Implementation
+ * @category Serialization
+ */
+export declare abstract class Proof extends Serializable {
+}
+//# sourceMappingURL=proof.d.ts.map

package/dist/core/crypto/proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof.d.ts","sourceRoot":"","sources":["../../../src/core/crypto/proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;GAKG;AACH,8BAAsB,KAAM,SAAQ,YAAY;CAAG"}

package/dist/core/crypto/proof.js

@@ -0,0 +1,10 @@
+import { Serializable } from "../../bcs/index.js";
+/**
+ * An abstract representation of a cryptographic proof associated with specific
+ * zero-knowledge proof schemes, such as Groth16 and PLONK.
+ * @group Implementation
+ * @category Serialization
+ */
+export class Proof extends Serializable {
+}
+//# sourceMappingURL=proof.js.map

package/dist/core/crypto/proof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof.js","sourceRoot":"","sources":["../../../src/core/crypto/proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;GAKG;AACH,MAAM,OAAgB,KAAM,SAAQ,YAAY;CAAG"}

package/dist/core/crypto/publicKey.d.ts

@@ -0,0 +1,92 @@
+import { AptosConfig } from "../../api/aptosConfig.js";
+import { Serializable } from "../../bcs/index.js";
+import { HexInput } from "../../types/index.js";
+import { AuthenticationKey } from "../authenticationKey.js";
+import { Signature } from "./signature.js";
+/**
+ * Represents the arguments required to verify a digital signature.
+ *
+ * @param message - The original message that was signed.
+ * @param signature - The signature to be verified against the message.
+ * @group Implementation
+ * @category Serialization
+ */
+export interface VerifySignatureArgs {
+    message: HexInput;
+    signature: Signature;
+}
+/**
+ * Represents the arguments required to verify a digital signature asynchronously.
+ *
+ * The validity of certain types of signatures are dependent on network state.  This is the case for
+ * Keyless signatures which need to lookup the verification key and keyless configuration.
+ *
+ * @param aptosConfig - The Aptos configuration to use
+ * @param message - The original message that was signed.
+ * @param signature - The signature to be verified against the message.
+ * @group Implementation
+ * @category Serialization
+ */
+export type VerifySignatureAsyncArgs = VerifySignatureArgs & {
+    aptosConfig: AptosConfig;
+    options?: any;
+};
+/**
+ * Represents an abstract public key.
+ *
+ * This class provides a common interface for verifying signatures associated with the public key.
+ * It allows for the retrieval of the raw public key bytes and the public key in a hexadecimal string format.
+ * @group Implementation
+ * @category Serialization
+ */
+export declare abstract class PublicKey extends Serializable {
+    /**
+     * Verifies that the private key associated with this public key signed the message with the given signature.
+     * @param args.message The message that was signed
+     * @param args.signature The signature to verify
+     * @group Implementation
+     * @category Serialization
+     */
+    abstract verifySignature(args: VerifySignatureArgs): boolean;
+    /**
+     * Verifies signature with the public key and makes any network calls required to get state required to verify the signature.
+     * @param args.aptosConfig The Aptos configuration
+     * @param args.message The message that was signed
+     * @param args.signature The signature to verify
+     * @group Implementation
+     * @category Serialization
+     */
+    verifySignatureAsync(args: VerifySignatureAsyncArgs): Promise<boolean>;
+    /**
+     * Get the raw public key bytes
+     * @group Implementation
+     * @category Serialization
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with a 0x prefix.
+     *
+     * @returns The public key in hex format.
+     * @group Implementation
+     * @category Serialization
+     */
+    toString(): string;
+}
+/**
+ * An abstract representation of an account public key.
+ *
+ * Provides a common interface for deriving an authentication key.
+ *
+ * @abstract
+ * @group Implementation
+ * @category Serialization
+ */
+export declare abstract class AccountPublicKey extends PublicKey {
+    /**
+     * Get the authentication key associated with this public key
+     * @group Implementation
+     * @category Serialization
+     */
+    abstract authKey(): AuthenticationKey;
+}
+//# sourceMappingURL=publicKey.d.ts.map

package/dist/core/crypto/publicKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicKey.d.ts","sourceRoot":"","sources":["../../../src/core/crypto/publicKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,QAAQ,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,wBAAwB,GAAG,mBAAmB,GAAG;IAC3D,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,CAAC,EAAE,GAAG,CAAC;CACf,CAAC;AAEF;;;;;;;GAOG;AACH,8BAAsB,SAAU,SAAQ,YAAY;IAClD;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAE5D;;;;;;;OAOG;IACG,oBAAoB,CAAC,IAAI,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI5E;;;;OAIG;IACH,YAAY,IAAI,UAAU;IAI1B;;;;;;OAMG;IACH,QAAQ,IAAI,MAAM;CAInB;AAED;;;;;;;;GAQG;AACH,8BAAsB,gBAAiB,SAAQ,SAAS;IACtD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,IAAI,iBAAiB;CACtC"}

package/dist/core/crypto/publicKey.js

@@ -0,0 +1,54 @@
+import { Serializable } from "../../bcs/index.js";
+import { Hex } from "../hex.js";
+/**
+ * Represents an abstract public key.
+ *
+ * This class provides a common interface for verifying signatures associated with the public key.
+ * It allows for the retrieval of the raw public key bytes and the public key in a hexadecimal string format.
+ * @group Implementation
+ * @category Serialization
+ */
+export class PublicKey extends Serializable {
+    /**
+     * Verifies signature with the public key and makes any network calls required to get state required to verify the signature.
+     * @param args.aptosConfig The Aptos configuration
+     * @param args.message The message that was signed
+     * @param args.signature The signature to verify
+     * @group Implementation
+     * @category Serialization
+     */
+    async verifySignatureAsync(args) {
+        return this.verifySignature(args);
+    }
+    /**
+     * Get the raw public key bytes
+     * @group Implementation
+     * @category Serialization
+     */
+    toUint8Array() {
+        return this.bcsToBytes();
+    }
+    /**
+     * Get the public key as a hex string with a 0x prefix.
+     *
+     * @returns The public key in hex format.
+     * @group Implementation
+     * @category Serialization
+     */
+    toString() {
+        const bytes = this.toUint8Array();
+        return Hex.fromHexInput(bytes).toString();
+    }
+}
+/**
+ * An abstract representation of an account public key.
+ *
+ * Provides a common interface for deriving an authentication key.
+ *
+ * @abstract
+ * @group Implementation
+ * @category Serialization
+ */
+export class AccountPublicKey extends PublicKey {
+}
+//# sourceMappingURL=publicKey.js.map

package/dist/core/crypto/publicKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicKey.js","sourceRoot":"","sources":["../../../src/core/crypto/publicKey.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAiChC;;;;;;;GAOG;AACH,MAAM,OAAgB,SAAU,SAAQ,YAAY;IAUlD;;;;;;;OAOG;IACH,KAAK,CAAC,oBAAoB,CAAC,IAA8B;QACvD,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;OAIG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;IAED;;;;;;OAMG;IACH,QAAQ;QACN,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QAClC,OAAO,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC5C,CAAC;CACF;AAED;;;;;;;;GAQG;AACH,MAAM,OAAgB,gBAAiB,SAAQ,SAAS;CAOvD"}