wowok 2.1.39 → 2.1.41

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

@@ -1,63 +1 @@
-// 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";
-const ED25519_CURVE = "ed25519 seed";
-const HARDENED_OFFSET = 0x80000000;
-const pathRegex = new RegExp("^m(\\/[0-9]+')+$");
-const replaceDerive = (val) => val.replace("'", "");
-const getMasterKeyFromSeed = (seed) => {
-    const h = hmac.create(sha512, ED25519_CURVE);
-    const I = h.update(fromHex(seed)).digest();
-    const IL = I.slice(0, 32);
-    const IR = I.slice(32);
-    return {
-        key: IL,
-        chainCode: IR,
-    };
-};
-const CKDPriv = ({ key, chainCode }, index) => {
-    const indexBuffer = new ArrayBuffer(4);
-    const cv = new DataView(indexBuffer);
-    cv.setUint32(0, index);
-    const data = new Uint8Array(1 + key.length + indexBuffer.byteLength);
-    data.set(new Uint8Array(1).fill(0));
-    data.set(key, 1);
-    data.set(new Uint8Array(indexBuffer, 0, indexBuffer.byteLength), key.length + 1);
-    const I = hmac.create(sha512, chainCode).update(data).digest();
-    const IL = I.slice(0, 32);
-    const IR = I.slice(32);
-    return {
-        key: IL,
-        chainCode: IR,
-    };
-};
-const isValidPath = (path) => {
-    if (!pathRegex.test(path)) {
-        return false;
-    }
-    return !path
-        .split("/")
-        .slice(1)
-        .map(replaceDerive)
-        .some(isNaN /* ts T_T*/);
-};
-export const derivePath = (path, seed, offset = HARDENED_OFFSET) => {
-    if (!isValidPath(path)) {
-        throw new Error("Invalid derivation path");
-    }
-    const { key, chainCode } = getMasterKeyFromSeed(seed);
-    const segments = path
-        .split("/")
-        .slice(1)
-        .map(replaceDerive)
-        .map((el) => parseInt(el, 10));
-    return segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
-        key,
-        chainCode,
-    });
-};
-//# sourceMappingURL=ed25519-hd-key.js.map
+import{fromHex}from'@mysten/bcs';import{hmac}from'@noble/hashes/hmac';import{sha512}from'@noble/hashes/sha512';const ED25519_CURVE='ed25519\x20seed',HARDENED_OFFSET=0x80000000,pathRegex=new RegExp('^m(\x5c/[0-9]+\x27)+$'),replaceDerive=a=>a['replace']('\x27',''),getMasterKeyFromSeed=a=>{const b=hmac['create'](sha512,ED25519_CURVE),c=b['update'](fromHex(a))['digest'](),d=c['slice'](0x0,0x20),e=c['slice'](0x20);return{'key':d,'chainCode':e};},CKDPriv=({key:a,chainCode:b},c)=>{const d=new ArrayBuffer(0x4),e=new DataView(d);e['setUint32'](0x0,c);const f=new Uint8Array(0x1+a['length']+d['byteLength']);f['set'](new Uint8Array(0x1)['fill'](0x0)),f['set'](a,0x1),f['set'](new Uint8Array(d,0x0,d['byteLength']),a['length']+0x1);const g=hmac['create'](sha512,b)['update'](f)['digest'](),h=g['slice'](0x0,0x20),i=g['slice'](0x20);return{'key':h,'chainCode':i};},isValidPath=a=>{if(!pathRegex['test'](a))return![];return!a['split']('/')['slice'](0x1)['map'](replaceDerive)['some'](isNaN);};export const derivePath=(a,b,c=HARDENED_OFFSET)=>{if(!isValidPath(a))throw new Error('Invalid\x20derivation\x20path');const {key:d,chainCode:e}=getMasterKeyFromSeed(b),f=a['split']('/')['slice'](0x1)['map'](replaceDerive)['map'](g=>parseInt(g,0xa));return f['reduce']((g,h)=>CKDPriv(g,h+c),{'key':d,'chainCode':e});};

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

@@ -1,5 +1 @@
-// 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
+export{DEFAULT_ED25519_DERIVATION_PATH,Ed25519Keypair}from'./keypair.js';export{Ed25519PublicKey}from'./publickey.js';

package/dist/esm/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/esm/keypairs/ed25519/keypair.js

@@ -1,140 +1 @@
-// 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) {
-            this.keypair = {
-                publicKey: keypair.publicKey,
-                secretKey: keypair.secretKey.slice(0, 32),
-            };
-        }
-        else {
-            const privateKey = ed25519.utils.randomPrivateKey();
-            this.keypair = {
-                publicKey: ed25519.getPublicKey(privateKey),
-                secretKey: privateKey,
-            };
-        }
-    }
-    /**
-     * 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({
-            publicKey: ed25519.getPublicKey(secretKey),
-            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);
-            if (decoded.scheme !== "ED25519") {
-                throw new Error(`Expected a ED25519 keypair, got ${decoded.scheme}`);
-            }
-            return this.fromSecretKey(decoded.secretKey, options);
-        }
-        const secretKeyLength = secretKey.length;
-        if (secretKeyLength !== PRIVATE_KEY_SIZE) {
-            throw new Error(`Wrong secretKey size. Expected ${PRIVATE_KEY_SIZE} bytes, got ${secretKeyLength}.`);
-        }
-        const keypair = {
-            publicKey: ed25519.getPublicKey(secretKey),
-            secretKey,
-        };
-        if (!options || !options.skipValidation) {
-            const encoder = new TextEncoder();
-            const signData = encoder.encode("sui validation");
-            const signature = ed25519.sign(signData, secretKey);
-            if (!ed25519.verify(signature, signData, keypair.publicKey)) {
-                throw new Error("provided secretKey is invalid");
-            }
-        }
-        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;
-        }
-        if (!isValidHardenedPath(path)) {
-            throw new Error("Invalid derivation path");
-        }
-        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;
-        }
-        if (!isValidHardenedPath(path)) {
-            throw new Error("Invalid derivation path");
-        }
-        const { key } = derivePath(path, seedHex);
-        return Ed25519Keypair.fromSecretKey(key);
-    }
-}
-//# sourceMappingURL=keypair.js.map
+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\x27/784\x27/0\x27/0\x27/0\x27';export class Ed25519Keypair extends Keypair{['keypair'];constructor(a){super();if(a)this['keypair']={'publicKey':a['publicKey'],'secretKey':a['secretKey']['slice'](0x0,0x20)};else{const b=ed25519['utils']['randomPrivateKey']();this['keypair']={'publicKey':ed25519['getPublicKey'](b),'secretKey':b};}}['getKeyScheme'](){return'ED25519';}static['generate'](){const a=ed25519['utils']['randomPrivateKey']();return new Ed25519Keypair({'publicKey':ed25519['getPublicKey'](a),'secretKey':a});}static['fromSecretKey'](a,b){if(typeof a==='string'){const e=decodeWowPrivateKey(a);if(e['scheme']!=='ED25519')throw new Error('Expected\x20a\x20ED25519\x20keypair,\x20got\x20'+e['scheme']);return this['fromSecretKey'](e['secretKey'],b);}const c=a['length'];if(c!==PRIVATE_KEY_SIZE)throw new Error('Wrong\x20secretKey\x20size.\x20Expected\x20'+PRIVATE_KEY_SIZE+'\x20bytes,\x20got\x20'+c+'.');const d={'publicKey':ed25519['getPublicKey'](a),'secretKey':a};if(!b||!b['skipValidation']){const f=new TextEncoder(),g=f['encode']('sui\x20validation'),h=ed25519['sign'](g,a);if(!ed25519['verify'](h,g,d['publicKey']))throw new Error('provided\x20secretKey\x20is\x20invalid');}return new Ed25519Keypair(d);}['getPublicKey'](){return new Ed25519PublicKey(this['keypair']['publicKey']);}['getSecretKey'](){return encodeWowPrivateKey(this['keypair']['secretKey']['slice'](0x0,PRIVATE_KEY_SIZE),this['getKeyScheme']());}async['sign'](a){return ed25519['sign'](a,this['keypair']['secretKey']);}static['deriveKeypair'](a,b){b==null&&(b=DEFAULT_ED25519_DERIVATION_PATH);if(!isValidHardenedPath(b))throw new Error('Invalid\x20derivation\x20path');const {key:c}=derivePath(b,mnemonicToSeedHex(a));return Ed25519Keypair['fromSecretKey'](c);}static['deriveKeypairFromSeed'](a,b){b==null&&(b=DEFAULT_ED25519_DERIVATION_PATH);if(!isValidHardenedPath(b))throw new Error('Invalid\x20derivation\x20path');const {key:c}=derivePath(b,a);return Ed25519Keypair['fromSecretKey'](c);}}

package/dist/esm/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/esm/keypairs/ed25519/publickey.js

@@ -1,72 +1 @@
-// 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") {
-            this.data = fromBase64(value);
-        }
-        else if (value instanceof Uint8Array) {
-            this.data = value;
-        }
-        else {
-            this.data = Uint8Array.from(value);
-        }
-        if (this.data.length !== PUBLIC_KEY_SIZE) {
-            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") {
-            const parsed = parseSerializedKeypairSignature(signature);
-            if (parsed.signatureScheme !== "ED25519") {
-                throw new Error("Invalid signature scheme");
-            }
-            if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) {
-                throw new Error("Signature does not match public key");
-            }
-            bytes = parsed.signature;
-        }
-        else {
-            bytes = signature;
-        }
-        return ed25519.verify(bytes, message, this.toRawBytes());
-    }
-}
-//# sourceMappingURL=publickey.js.map
+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=0x20;export class Ed25519PublicKey extends PublicKey{static ['SIZE']=PUBLIC_KEY_SIZE;['data'];constructor(a){super();if(typeof a==='string')this['data']=fromBase64(a);else a instanceof Uint8Array?this['data']=a:this['data']=Uint8Array['from'](a);if(this['data']['length']!==PUBLIC_KEY_SIZE)throw new Error('Invalid\x20public\x20key\x20input.\x20Expected\x20'+PUBLIC_KEY_SIZE+'\x20bytes,\x20got\x20'+this['data']['length']);}['equals'](a){return super['equals'](a);}['toRawBytes'](){return this['data'];}['flag'](){return SIGNATURE_SCHEME_TO_FLAG['ED25519'];}async['verify'](a,b){let c;if(typeof b==='string'){const d=parseSerializedKeypairSignature(b);if(d['signatureScheme']!=='ED25519')throw new Error('Invalid\x20signature\x20scheme');if(!bytesEqual(this['toRawBytes'](),d['publicKey']))throw new Error('Signature\x20does\x20not\x20match\x20public\x20key');c=d['signature'];}else c=b;return ed25519['verify'](c,a,this['toRawBytes']());}}

package/dist/esm/keypairs/index.js

@@ -1,7 +1 @@
-// 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
+export*from'./ed25519/index.js';export*from'./passkey/index.js';export*from'./secp256k1/index.js';export*from'./secp256r1/index.js';

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

@@ -1,5 +1 @@
-// 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
+export{PasskeyKeypair,BrowserPasskeyProvider,findCommonPublicKey}from'./keypair.js';export{PasskeyPublicKey}from'./publickey.js';

package/dist/esm/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 {};