wowok 2.1.38 → 2.1.40

package/dist/cjs/keypairs/ed25519/ed25519-hd-key.js

@@ -1,7 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-// This is adapted from https://github.com/alepop/ed25519-hd-key replacing create-hmac
-// with @noble/hashes to be browser compatible.
 import { fromHex } from "@mysten/bcs";
 import { hmac } from "@noble/hashes/hmac";
 import { sha512 } from "@noble/hashes/sha512";
@@ -43,7 +39,7 @@ const isValidPath = (path) => {
         .split("/")
         .slice(1)
         .map(replaceDerive)
-        .some(isNaN /* ts T_T*/);
+        .some(isNaN);
 };
 export const derivePath = (path, seed, offset = HARDENED_OFFSET) => {
     if (!isValidPath(path)) {
@@ -60,4 +56,3 @@ export const derivePath = (path, seed, offset = HARDENED_OFFSET) => {
         chainCode,
     });
 };
-//# sourceMappingURL=ed25519-hd-key.js.map

package/dist/cjs/keypairs/ed25519/index.js

@@ -1,5 +1,2 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 export { DEFAULT_ED25519_DERIVATION_PATH, Ed25519Keypair, } from "./keypair.js";
 export { Ed25519PublicKey } from "./publickey.js";
-//# sourceMappingURL=index.js.map

package/dist/cjs/keypairs/ed25519/keypair.d.ts

@@ -2,73 +2,21 @@ import { Keypair } from "../../cryptography/keypair.js";
 import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
 import { Ed25519PublicKey } from "./publickey.js";
 export declare const DEFAULT_ED25519_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
-/**
- * Ed25519 Keypair data. The publickey is the 32-byte public key and
- * the secretkey is 64-byte, where the first 32 bytes is the secret
- * key and the last 32 bytes is the public key.
- */
 export interface Ed25519KeypairData {
     publicKey: Uint8Array;
     secretKey: Uint8Array;
 }
-/**
- * An Ed25519 Keypair used for signing transactions.
- */
 export declare class Ed25519Keypair extends Keypair {
     private keypair;
-    /**
-     * Create a new Ed25519 keypair instance.
-     * Generate random keypair if no {@link Ed25519Keypair} is provided.
-     *
-     * @param keypair Ed25519 keypair
-     */
     constructor(keypair?: Ed25519KeypairData);
-    /**
-     * Get the key scheme of the keypair ED25519
-     */
     getKeyScheme(): SignatureScheme;
-    /**
-     * Generate a new random Ed25519 keypair
-     */
     static generate(): Ed25519Keypair;
-    /**
-     * Create a Ed25519 keypair from a raw secret key byte array, also known as seed.
-     * This is NOT the private scalar which is result of hashing and bit clamping of
-     * the raw secret key.
-     *
-     * @throws error if the provided secret key is invalid and validation is not skipped.
-     *
-     * @param secretKey secret key as a byte array or Bech32 secret key string
-     * @param options: skip secret key validation
-     */
     static fromSecretKey(secretKey: Uint8Array | string, options?: {
         skipValidation?: boolean;
     }): Ed25519Keypair;
-    /**
-     * The public key for this Ed25519 keypair
-     */
     getPublicKey(): Ed25519PublicKey;
-    /**
-     * The Bech32 secret key string for this Ed25519 keypair
-     */
     getSecretKey(): string;
-    /**
-     * Return the signature for the provided data using Ed25519.
-     */
     sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    /**
-     * Derive Ed25519 keypair from mnemonics and path. The mnemonics must be normalized
-     * and validated against the english wordlist.
-     *
-     * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
-     * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
-     */
     static deriveKeypair(mnemonics: string, path?: string): Ed25519Keypair;
-    /**
-     * Derive Ed25519 keypair from mnemonicSeed and path.
-     *
-     * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
-     * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
-     */
     static deriveKeypairFromSeed(seedHex: string, path?: string): Ed25519Keypair;
 }

package/dist/cjs/keypairs/ed25519/keypair.js

@@ -1,22 +1,11 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 import { ed25519 } from "@noble/curves/ed25519";
 import { decodeWowPrivateKey, encodeWowPrivateKey, Keypair, PRIVATE_KEY_SIZE, } from "../../cryptography/keypair.js";
 import { isValidHardenedPath, mnemonicToSeedHex, } from "../../cryptography/mnemonics.js";
 import { derivePath } from "./ed25519-hd-key.js";
 import { Ed25519PublicKey } from "./publickey.js";
 export const DEFAULT_ED25519_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
-/**
- * An Ed25519 Keypair used for signing transactions.
- */
 export class Ed25519Keypair extends Keypair {
     keypair;
-    /**
-     * Create a new Ed25519 keypair instance.
-     * Generate random keypair if no {@link Ed25519Keypair} is provided.
-     *
-     * @param keypair Ed25519 keypair
-     */
     constructor(keypair) {
         super();
         if (keypair) {
@@ -33,15 +22,9 @@ export class Ed25519Keypair extends Keypair {
             };
         }
     }
-    /**
-     * Get the key scheme of the keypair ED25519
-     */
     getKeyScheme() {
         return "ED25519";
     }
-    /**
-     * Generate a new random Ed25519 keypair
-     */
     static generate() {
         const secretKey = ed25519.utils.randomPrivateKey();
         return new Ed25519Keypair({
@@ -49,16 +32,6 @@ export class Ed25519Keypair extends Keypair {
             secretKey,
         });
     }
-    /**
-     * Create a Ed25519 keypair from a raw secret key byte array, also known as seed.
-     * This is NOT the private scalar which is result of hashing and bit clamping of
-     * the raw secret key.
-     *
-     * @throws error if the provided secret key is invalid and validation is not skipped.
-     *
-     * @param secretKey secret key as a byte array or Bech32 secret key string
-     * @param options: skip secret key validation
-     */
     static fromSecretKey(secretKey, options) {
         if (typeof secretKey === "string") {
             const decoded = decodeWowPrivateKey(secretKey);
@@ -85,31 +58,15 @@ export class Ed25519Keypair extends Keypair {
         }
         return new Ed25519Keypair(keypair);
     }
-    /**
-     * The public key for this Ed25519 keypair
-     */
     getPublicKey() {
         return new Ed25519PublicKey(this.keypair.publicKey);
     }
-    /**
-     * The Bech32 secret key string for this Ed25519 keypair
-     */
     getSecretKey() {
         return encodeWowPrivateKey(this.keypair.secretKey.slice(0, PRIVATE_KEY_SIZE), this.getKeyScheme());
     }
-    /**
-     * Return the signature for the provided data using Ed25519.
-     */
     async sign(data) {
         return ed25519.sign(data, this.keypair.secretKey);
     }
-    /**
-     * Derive Ed25519 keypair from mnemonics and path. The mnemonics must be normalized
-     * and validated against the english wordlist.
-     *
-     * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
-     * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
-     */
     static deriveKeypair(mnemonics, path) {
         if (path == null) {
             path = DEFAULT_ED25519_DERIVATION_PATH;
@@ -120,12 +77,6 @@ export class Ed25519Keypair extends Keypair {
         const { key } = derivePath(path, mnemonicToSeedHex(mnemonics));
         return Ed25519Keypair.fromSecretKey(key);
     }
-    /**
-     * Derive Ed25519 keypair from mnemonicSeed and path.
-     *
-     * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
-     * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
-     */
     static deriveKeypairFromSeed(seedHex, path) {
         if (path == null) {
             path = DEFAULT_ED25519_DERIVATION_PATH;
@@ -137,4 +88,3 @@ export class Ed25519Keypair extends Keypair {
         return Ed25519Keypair.fromSecretKey(key);
     }
 }
-//# sourceMappingURL=keypair.js.map

package/dist/cjs/keypairs/ed25519/publickey.d.ts

@@ -1,30 +1,11 @@
 import { PublicKey } from "../../cryptography/publickey.js";
 import type { PublicKeyInitData } from "../../cryptography/publickey.js";
-/**
- * An Ed25519 public key
- */
 export declare class Ed25519PublicKey extends PublicKey {
     static SIZE: number;
     private data;
-    /**
-     * Create a new Ed25519PublicKey object
-     * @param value ed25519 public key as buffer or base-64 encoded string
-     */
     constructor(value: PublicKeyInitData);
-    /**
-     * Checks if two Ed25519 public keys are equal
-     */
     equals(publicKey: Ed25519PublicKey): boolean;
-    /**
-     * Return the byte array representation of the Ed25519 public key
-     */
     toRawBytes(): Uint8Array<ArrayBuffer>;
-    /**
-     * Return the Sui address associated with this Ed25519 public key
-     */
     flag(): number;
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
     verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
 }

package/dist/cjs/keypairs/ed25519/publickey.js

@@ -1,20 +1,11 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 import { fromBase64 } from "@mysten/bcs";
 import { ed25519 } from "@noble/curves/ed25519";
 import { bytesEqual, parseSerializedKeypairSignature, PublicKey, } from "../../cryptography/publickey.js";
 import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.js";
 const PUBLIC_KEY_SIZE = 32;
-/**
- * An Ed25519 public key
- */
 export class Ed25519PublicKey extends PublicKey {
     static SIZE = PUBLIC_KEY_SIZE;
     data;
-    /**
-     * Create a new Ed25519PublicKey object
-     * @param value ed25519 public key as buffer or base-64 encoded string
-     */
     constructor(value) {
         super();
         if (typeof value === "string") {
@@ -30,27 +21,15 @@ export class Ed25519PublicKey extends PublicKey {
             throw new Error(`Invalid public key input. Expected ${PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
         }
     }
-    /**
-     * Checks if two Ed25519 public keys are equal
-     */
     equals(publicKey) {
         return super.equals(publicKey);
     }
-    /**
-     * Return the byte array representation of the Ed25519 public key
-     */
     toRawBytes() {
         return this.data;
     }
-    /**
-     * Return the Sui address associated with this Ed25519 public key
-     */
     flag() {
         return SIGNATURE_SCHEME_TO_FLAG["ED25519"];
     }
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
     async verify(message, signature) {
         let bytes;
         if (typeof signature === "string") {
@@ -69,4 +48,3 @@ export class Ed25519PublicKey extends PublicKey {
         return ed25519.verify(bytes, message, this.toRawBytes());
     }
 }
-//# sourceMappingURL=publickey.js.map

package/dist/cjs/keypairs/index.js

@@ -1,7 +1,4 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
 export * from "./ed25519/index.js";
 export * from "./passkey/index.js";
 export * from "./secp256k1/index.js";
 export * from "./secp256r1/index.js";
-//# sourceMappingURL=index.js.map

package/dist/cjs/keypairs/passkey/index.js

@@ -1,5 +1,2 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 export { PasskeyKeypair, BrowserPasskeyProvider, findCommonPublicKey, } from "./keypair.js";
 export { PasskeyPublicKey } from "./publickey.js";
-//# sourceMappingURL=index.js.map

package/dist/cjs/keypairs/passkey/keypair.d.ts

@@ -18,96 +18,16 @@ export declare class BrowserPasskeyProvider implements PasskeyProvider {
     create(): Promise<RegistrationCredential>;
     get(challenge: Uint8Array): Promise<AuthenticationCredential>;
 }
-/**
- * @experimental
- * A passkey signer used for signing transactions. This is a client side implementation for [SIP-9](https://github.com/sui-foundation/sips/blob/main/sips/sip-9.md).
- */
 export declare class PasskeyKeypair extends Signer {
     private publicKey;
     private provider;
-    /**
-     * Get the key scheme of passkey,
-     */
     getKeyScheme(): SignatureScheme;
-    /**
-     * Creates an instance of Passkey signer. If no passkey wallet had created before,
-     * use `getPasskeyInstance`. For example:
-     * ```
-     * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
-     * 	  rpName: 'Sui Passkey Example',
-     * 	  rpId: window.location.hostname,
-     * } as BrowserPasswordProviderOptions);
-     * const signer = await PasskeyKeypair.getPasskeyInstance(provider);
-     * ```
-     *
-     * If there are existing passkey wallet, use `signAndRecover` to identify the correct
-     * public key and then initialize the instance. See usage in `signAndRecover`.
-     */
     constructor(publicKey: Uint8Array, provider: PasskeyProvider);
-    /**
-     * Creates an instance of Passkey signer invoking the passkey from navigator.
-     * Note that this will invoke the passkey device to create a fresh credential.
-     * Should only be called if passkey wallet is created for the first time.
-     *
-     * @param provider - the passkey provider.
-     * @returns the passkey instance.
-     */
     static getPasskeyInstance(provider: PasskeyProvider): Promise<PasskeyKeypair>;
-    /**
-     * Return the public key for this passkey.
-     */
     getPublicKey(): PublicKey;
-    /**
-     * Return the signature for the provided data (i.e. blake2b(intent_message)).
-     * This is sent to passkey as the challenge field.
-     */
     sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    /**
-     * This overrides the base class implementation that accepts the raw bytes and signs its
-     * digest of the intent message, then serialize it with the passkey flag.
-     */
     signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes>;
-    /**
-     * Given a message, asks the passkey device to sign it and return all (up to 4) possible public keys.
-     * See: https://bitcoin.stackexchange.com/questions/81232/how-is-public-key-extracted-from-message-digital-signature-address
-     *
-     * This is useful if the user previously created passkey wallet with the origin, but the wallet session
-     * does not have the public key / address. By calling this method twice with two different messages, the
-     * wallet can compare the returned public keys and uniquely identify the previously created passkey wallet
-     * using `findCommonPublicKey`.
-     *
-     * Alternatively, one call can be made and all possible public keys should be checked onchain to see if
-     * there is any assets.
-     *
-     * Once the correct public key is identified, a passkey instance can then be initialized with this public key.
-     *
-     * Example usage to recover wallet with two signing calls:
-     * ```
-     * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
-     *     rpName: 'Sui Passkey Example',
-     * 	   rpId: window.location.hostname,
-     * } as BrowserPasswordProviderOptions);
-     * const testMessage = new TextEncoder().encode('Hello world!');
-     * const possiblePks = await PasskeyKeypair.signAndRecover(provider, testMessage);
-     * const testMessage2 = new TextEncoder().encode('Hello world 2!');
-     * const possiblePks2 = await PasskeyKeypair.signAndRecover(provider, testMessage2);
-     * const commonPk = findCommonPublicKey(possiblePks, possiblePks2);
-     * const signer = new PasskeyKeypair(provider, commonPk.toRawBytes());
-     * ```
-     *
-     * @param provider - the passkey provider.
-     * @param message - the message to sign.
-     * @returns all possible public keys.
-     */
     static signAndRecover(provider: PasskeyProvider, message: Uint8Array): Promise<PublicKey[]>;
 }
-/**
- * Finds the unique public key that exists in both arrays, throws error if the common
- * pubkey does not equal to one.
- *
- * @param arr1 - The first pubkeys array.
- * @param arr2 - The second pubkeys array.
- * @returns The only common pubkey in both arrays.
- */
 export declare function findCommonPublicKey(arr1: PublicKey[], arr2: PublicKey[]): PublicKey;
 export {};

package/dist/cjs/keypairs/passkey/keypair.js

@@ -1,5 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
 import { toBase64 } from "@mysten/bcs";
 import { secp256r1 } from "@noble/curves/p256";
 import { blake2b } from "@noble/hashes/blake2b";
@@ -8,7 +6,6 @@ import { randomBytes } from "@noble/hashes/utils";
 import { PasskeyAuthenticator } from "../../bcs/bcs.js";
 import { messageWithIntent, SIGNATURE_SCHEME_TO_FLAG, Signer, } from "../../cryptography/index.js";
 import { parseDerSPKI, PASSKEY_PUBLIC_KEY_SIZE, PASSKEY_SIGNATURE_SIZE, PasskeyPublicKey, } from "./publickey.js";
-// Default browser implementation
 export class BrowserPasskeyProvider {
     #name;
     #options;
@@ -54,48 +51,18 @@ export class BrowserPasskeyProvider {
         }));
     }
 }
-/**
- * @experimental
- * A passkey signer used for signing transactions. This is a client side implementation for [SIP-9](https://github.com/sui-foundation/sips/blob/main/sips/sip-9.md).
- */
 export class PasskeyKeypair extends Signer {
     publicKey;
     provider;
-    /**
-     * Get the key scheme of passkey,
-     */
     getKeyScheme() {
         return "Passkey";
     }
-    /**
-     * Creates an instance of Passkey signer. If no passkey wallet had created before,
-     * use `getPasskeyInstance`. For example:
-     * ```
-     * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
-     * 	  rpName: 'Sui Passkey Example',
-     * 	  rpId: window.location.hostname,
-     * } as BrowserPasswordProviderOptions);
-     * const signer = await PasskeyKeypair.getPasskeyInstance(provider);
-     * ```
-     *
-     * If there are existing passkey wallet, use `signAndRecover` to identify the correct
-     * public key and then initialize the instance. See usage in `signAndRecover`.
-     */
     constructor(publicKey, provider) {
         super();
         this.publicKey = publicKey;
         this.provider = provider;
     }
-    /**
-     * Creates an instance of Passkey signer invoking the passkey from navigator.
-     * Note that this will invoke the passkey device to create a fresh credential.
-     * Should only be called if passkey wallet is created for the first time.
-     *
-     * @param provider - the passkey provider.
-     * @returns the passkey instance.
-     */
     static async getPasskeyInstance(provider) {
-        // create a passkey secp256r1 with the provider.
         const credential = await provider.create();
         if (!credential.response.getPublicKey()) {
             throw new Error("Invalid credential create response");
@@ -108,54 +75,35 @@ export class PasskeyKeypair extends Signer {
             return new PasskeyKeypair(pubkeyCompressed, provider);
         }
     }
-    /**
-     * Return the public key for this passkey.
-     */
     getPublicKey() {
         return new PasskeyPublicKey(this.publicKey);
     }
-    /**
-     * Return the signature for the provided data (i.e. blake2b(intent_message)).
-     * This is sent to passkey as the challenge field.
-     */
     async sign(data) {
-        // asks the passkey to sign over challenge as the data.
         const credential = await this.provider.get(data);
-        // parse authenticatorData (as bytes), clientDataJSON (decoded as string).
         const authenticatorData = new Uint8Array(credential.response.authenticatorData);
-        const clientDataJSON = new Uint8Array(credential.response.clientDataJSON); // response.clientDataJSON is already UTF-8 encoded JSON
+        const clientDataJSON = new Uint8Array(credential.response.clientDataJSON);
         const decoder = new TextDecoder();
         const clientDataJSONString = decoder.decode(clientDataJSON);
-        // parse the signature from DER format, normalize and convert to compressed format (33 bytes).
         const sig = secp256r1.Signature.fromDER(new Uint8Array(credential.response.signature));
         const normalized = sig.normalizeS().toCompactRawBytes();
         if (normalized.length !== PASSKEY_SIGNATURE_SIZE ||
             this.publicKey.length !== PASSKEY_PUBLIC_KEY_SIZE) {
             throw new Error("Invalid signature or public key length");
         }
-        // construct userSignature as flag || sig || pubkey for the secp256r1 signature.
         const arr = new Uint8Array(1 + normalized.length + this.publicKey.length);
         arr.set([SIGNATURE_SCHEME_TO_FLAG["Secp256r1"]]);
         arr.set(normalized, 1);
         arr.set(this.publicKey, 1 + normalized.length);
-        // serialize all fields into a passkey signature according to https://github.com/sui-foundation/sips/blob/main/sips/sip-9.md#signature-encoding
         return PasskeyAuthenticator.serialize({
             authenticatorData: authenticatorData,
             clientDataJson: clientDataJSONString,
             userSignature: arr,
         }).toBytes();
     }
-    /**
-     * This overrides the base class implementation that accepts the raw bytes and signs its
-     * digest of the intent message, then serialize it with the passkey flag.
-     */
     async signWithIntent(bytes, intent) {
-        // prepend it into an intent message and computes the digest.
         const intentMessage = messageWithIntent(intent, bytes);
         const digest = blake2b(intentMessage, { dkLen: 32 });
-        // sign the digest.
         const signature = await this.sign(digest);
-        // prepend with the passkey flag.
         const serializedSignature = new Uint8Array(1 + signature.length);
         serializedSignature.set([
             SIGNATURE_SCHEME_TO_FLAG[this.getKeyScheme()],
@@ -166,38 +114,6 @@ export class PasskeyKeypair extends Signer {
             bytes: toBase64(bytes),
         };
     }
-    /**
-     * Given a message, asks the passkey device to sign it and return all (up to 4) possible public keys.
-     * See: https://bitcoin.stackexchange.com/questions/81232/how-is-public-key-extracted-from-message-digital-signature-address
-     *
-     * This is useful if the user previously created passkey wallet with the origin, but the wallet session
-     * does not have the public key / address. By calling this method twice with two different messages, the
-     * wallet can compare the returned public keys and uniquely identify the previously created passkey wallet
-     * using `findCommonPublicKey`.
-     *
-     * Alternatively, one call can be made and all possible public keys should be checked onchain to see if
-     * there is any assets.
-     *
-     * Once the correct public key is identified, a passkey instance can then be initialized with this public key.
-     *
-     * Example usage to recover wallet with two signing calls:
-     * ```
-     * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
-     *     rpName: 'Sui Passkey Example',
-     * 	   rpId: window.location.hostname,
-     * } as BrowserPasswordProviderOptions);
-     * const testMessage = new TextEncoder().encode('Hello world!');
-     * const possiblePks = await PasskeyKeypair.signAndRecover(provider, testMessage);
-     * const testMessage2 = new TextEncoder().encode('Hello world 2!');
-     * const possiblePks2 = await PasskeyKeypair.signAndRecover(provider, testMessage2);
-     * const commonPk = findCommonPublicKey(possiblePks, possiblePks2);
-     * const signer = new PasskeyKeypair(provider, commonPk.toRawBytes());
-     * ```
-     *
-     * @param provider - the passkey provider.
-     * @param message - the message to sign.
-     * @returns all possible public keys.
-     */
     static async signAndRecover(provider, message) {
         const credential = await provider.get(message);
         const fullMessage = messageFromAssertionResponse(credential.response);
@@ -217,14 +133,6 @@ export class PasskeyKeypair extends Signer {
         return res;
     }
 }
-/**
- * Finds the unique public key that exists in both arrays, throws error if the common
- * pubkey does not equal to one.
- *
- * @param arr1 - The first pubkeys array.
- * @param arr2 - The second pubkeys array.
- * @returns The only common pubkey in both arrays.
- */
 export function findCommonPublicKey(arr1, arr2) {
     const matchingPubkeys = [];
     for (const pubkey1 of arr1) {
@@ -239,13 +147,9 @@ export function findCommonPublicKey(arr1, arr2) {
     }
     return matchingPubkeys[0];
 }
-/**
- * Constructs the message that the passkey signature is produced over as authenticatorData || sha256(clientDataJSON).
- */
 function messageFromAssertionResponse(response) {
     const authenticatorData = new Uint8Array(response.authenticatorData);
     const clientDataJSON = new Uint8Array(response.clientDataJSON);
     const clientDataJSONDigest = sha256(clientDataJSON);
     return new Uint8Array([...authenticatorData, ...clientDataJSONDigest]);
 }
-//# sourceMappingURL=keypair.js.map

package/dist/cjs/keypairs/passkey/publickey.d.ts

@@ -3,64 +3,17 @@ import type { PublicKeyInitData } from "../../cryptography/publickey.js";
 export declare const PASSKEY_PUBLIC_KEY_SIZE = 33;
 export declare const PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;
 export declare const PASSKEY_SIGNATURE_SIZE = 64;
-/** Fixed DER header for secp256r1 SubjectPublicKeyInfo
-DER structure for P-256 SPKI:
-30 -- SEQUENCE
-  59 -- length (89 bytes)
-  30 -- SEQUENCE
-    13 -- length (19 bytes)
-    06 -- OBJECT IDENTIFIER
-      07 -- length
-      2A 86 48 CE 3D 02 01 -- id-ecPublicKey
-    06 -- OBJECT IDENTIFIER
-      08 -- length
-      2A 86 48 CE 3D 03 01 07 -- secp256r1/prime256v1
-  03 -- BIT STRING
-    42 -- length (66 bytes)
-    00 -- padding
-    ===== above bytes are considered header =====
-    04 || x || y -- uncompressed point (65 bytes: 0x04 || 32-byte x || 32-byte y)
-*/
 export declare const SECP256R1_SPKI_HEADER: Uint8Array<ArrayBuffer>;
-/**
- * A passkey public key
- */
 export declare class PasskeyPublicKey extends PublicKey {
     static SIZE: number;
     private data;
-    /**
-     * Create a new PasskeyPublicKey object
-     * @param value passkey public key as buffer or base-64 encoded string
-     */
     constructor(value: PublicKeyInitData);
-    /**
-     * Checks if two passkey public keys are equal
-     */
     equals(publicKey: PasskeyPublicKey): boolean;
-    /**
-     * Return the byte array representation of the Secp256r1 public key
-     */
     toRawBytes(): Uint8Array<ArrayBuffer>;
-    /**
-     * Return the Sui address associated with this Secp256r1 public key
-     */
     flag(): number;
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
     verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
 }
-/**
- * Parses a DER SubjectPublicKeyInfo into an uncompressed public key. This also verifies
- * that the curve used is P-256 (secp256r1).
- *
- * @param data: DER SubjectPublicKeyInfo
- * @returns uncompressed public key (`0x04 || x || y`)
- */
 export declare function parseDerSPKI(derBytes: Uint8Array): Uint8Array;
-/**
- * Parse signature from bytes or base64 string into the following fields.
- */
 export declare function parseSerializedPasskeySignature(signature: Uint8Array | string): {
     signatureScheme: "Passkey";
     serializedSignature: string;