wowok 2.1.39 → 2.1.41

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

@@ -1,251 +1 @@
-// 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";
-import { sha256 } from "@noble/hashes/sha256";
-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;
-    constructor(name, options) {
-        this.#name = name;
-        this.#options = options;
-    }
-    async create() {
-        return (await navigator.credentials.create({
-            publicKey: {
-                timeout: this.#options.timeout ?? 60000,
-                ...this.#options,
-                rp: {
-                    name: this.#name,
-                    ...this.#options.rp,
-                },
-                user: {
-                    name: this.#name,
-                    displayName: this.#name,
-                    ...this.#options.user,
-                    id: randomBytes(10),
-                },
-                challenge: new TextEncoder().encode("Create passkey wallet on Sui"),
-                pubKeyCredParams: [{ alg: -7, type: "public-key" }],
-                authenticatorSelection: {
-                    authenticatorAttachment: "cross-platform",
-                    residentKey: "required",
-                    requireResidentKey: true,
-                    userVerification: "required",
-                    ...this.#options.authenticatorSelection,
-                },
-            },
-        }));
-    }
-    async get(challenge) {
-        return (await navigator.credentials.get({
-            publicKey: {
-                challenge: challenge,
-                userVerification: this.#options.authenticatorSelection?.userVerification ||
-                    "required",
-                timeout: this.#options.timeout ?? 60000,
-            },
-        }));
-    }
-}
-/**
- * @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");
-        }
-        else {
-            const derSPKI = credential.response.getPublicKey();
-            const pubkeyUncompressed = parseDerSPKI(new Uint8Array(derSPKI));
-            const pubkey = secp256r1.ProjectivePoint.fromHex(pubkeyUncompressed);
-            const pubkeyCompressed = pubkey.toRawBytes(true);
-            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 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()],
-        ]);
-        serializedSignature.set(signature, 1);
-        return {
-            signature: toBase64(serializedSignature),
-            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);
-        const sig = secp256r1.Signature.fromDER(new Uint8Array(credential.response.signature));
-        const res = [];
-        for (let i = 0; i < 4; i++) {
-            const s = sig.addRecoveryBit(i);
-            try {
-                const pubkey = s.recoverPublicKey(sha256(fullMessage));
-                const pk = new PasskeyPublicKey(pubkey.toRawBytes(true));
-                res.push(pk);
-            }
-            catch {
-                continue;
-            }
-        }
-        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) {
-        for (const pubkey2 of arr2) {
-            if (pubkey1.equals(pubkey2)) {
-                matchingPubkeys.push(pubkey1);
-            }
-        }
-    }
-    if (matchingPubkeys.length !== 1) {
-        throw new Error("No unique public key found");
-    }
-    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
+import{toBase64}from'@mysten/bcs';import{secp256r1}from'@noble/curves/p256';import{blake2b}from'@noble/hashes/blake2b';import{sha256}from'@noble/hashes/sha256';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';export class BrowserPasskeyProvider{#name;#options;constructor(a,b){this.#name=a,this.#options=b;}async['create'](){return await navigator['credentials']['create']({'publicKey':{'timeout':this.#options['timeout']??0xea60,...this.#options,'rp':{'name':this.#name,...this.#options['rp']},'user':{'name':this.#name,'displayName':this.#name,...this.#options['user'],'id':randomBytes(0xa)},'challenge':new TextEncoder()['encode']('Create\x20passkey\x20wallet\x20on\x20Sui'),'pubKeyCredParams':[{'alg':-0x7,'type':'public-key'}],'authenticatorSelection':{'authenticatorAttachment':'cross-platform','residentKey':'required','requireResidentKey':!![],'userVerification':'required',...this.#options['authenticatorSelection']}}});}async['get'](a){return await navigator['credentials']['get']({'publicKey':{'challenge':a,'userVerification':this.#options['authenticatorSelection']?.['userVerification']||'required','timeout':this.#options['timeout']??0xea60}});}}export class PasskeyKeypair extends Signer{['publicKey'];['provider'];['getKeyScheme'](){return'Passkey';}constructor(a,b){super(),this['publicKey']=a,this['provider']=b;}static async['getPasskeyInstance'](a){const b=await a['create']();if(!b['response']['getPublicKey']())throw new Error('Invalid\x20credential\x20create\x20response');else{const c=b['response']['getPublicKey'](),d=parseDerSPKI(new Uint8Array(c)),e=secp256r1['ProjectivePoint']['fromHex'](d),f=e['toRawBytes'](!![]);return new PasskeyKeypair(f,a);}}['getPublicKey'](){return new PasskeyPublicKey(this['publicKey']);}async['sign'](a){const b=await this['provider']['get'](a),c=new Uint8Array(b['response']['authenticatorData']),d=new Uint8Array(b['response']['clientDataJSON']),e=new TextDecoder(),f=e['decode'](d),g=secp256r1['Signature']['fromDER'](new Uint8Array(b['response']['signature'])),h=g['normalizeS']()['toCompactRawBytes']();if(h['length']!==PASSKEY_SIGNATURE_SIZE||this['publicKey']['length']!==PASSKEY_PUBLIC_KEY_SIZE)throw new Error('Invalid\x20signature\x20or\x20public\x20key\x20length');const i=new Uint8Array(0x1+h['length']+this['publicKey']['length']);return i['set']([SIGNATURE_SCHEME_TO_FLAG['Secp256r1']]),i['set'](h,0x1),i['set'](this['publicKey'],0x1+h['length']),PasskeyAuthenticator['serialize']({'authenticatorData':c,'clientDataJson':f,'userSignature':i})['toBytes']();}async['signWithIntent'](a,b){const c=messageWithIntent(b,a),d=blake2b(c,{'dkLen':0x20}),e=await this['sign'](d),f=new Uint8Array(0x1+e['length']);return f['set']([SIGNATURE_SCHEME_TO_FLAG[this['getKeyScheme']()]]),f['set'](e,0x1),{'signature':toBase64(f),'bytes':toBase64(a)};}static async['signAndRecover'](a,b){const c=await a['get'](b),d=messageFromAssertionResponse(c['response']),e=secp256r1['Signature']['fromDER'](new Uint8Array(c['response']['signature'])),f=[];for(let g=0x0;g<0x4;g++){const h=e['addRecoveryBit'](g);try{const j=h['recoverPublicKey'](sha256(d)),k=new PasskeyPublicKey(j['toRawBytes'](!![]));f['push'](k);}catch{continue;}}return f;}}export function findCommonPublicKey(a,b){const c=[];for(const d of a){for(const e of b){d['equals'](e)&&c['push'](d);}}if(c['length']!==0x1)throw new Error('No\x20unique\x20public\x20key\x20found');return c[0x0];}function messageFromAssertionResponse(a){const b=new Uint8Array(a['authenticatorData']),c=new Uint8Array(a['clientDataJSON']),d=sha256(c);return new Uint8Array([...b,...d]);}

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

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

@@ -1,170 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-import { fromBase64, toBase64 } from "@mysten/bcs";
-import { secp256r1 } from "@noble/curves/p256";
-import { sha256 } from "@noble/hashes/sha256";
-import { PasskeyAuthenticator } from "../../bcs/bcs.js";
-import { bytesEqual, PublicKey } from "../../cryptography/publickey.js";
-import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.js";
-export const PASSKEY_PUBLIC_KEY_SIZE = 33;
-export const PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;
-export 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 const SECP256R1_SPKI_HEADER = new Uint8Array([
-    0x30,
-    0x59, // SEQUENCE, length 89
-    0x30,
-    0x13, // SEQUENCE, length 19
-    0x06,
-    0x07, // OID, length 7
-    0x2a,
-    0x86,
-    0x48,
-    0xce,
-    0x3d,
-    0x02,
-    0x01, // OID: 1.2.840.10045.2.1 (ecPublicKey)
-    0x06,
-    0x08, // OID, length 8
-    0x2a,
-    0x86,
-    0x48,
-    0xce,
-    0x3d,
-    0x03,
-    0x01,
-    0x07, // OID: 1.2.840.10045.3.1.7 (prime256v1/secp256r1)
-    0x03,
-    0x42, // BIT STRING, length 66
-    0x00, // no unused bits
-]);
-/**
- * A passkey public key
- */
-export class PasskeyPublicKey extends PublicKey {
-    static SIZE = PASSKEY_PUBLIC_KEY_SIZE;
-    data;
-    /**
-     * Create a new PasskeyPublicKey object
-     * @param value passkey 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 !== PASSKEY_PUBLIC_KEY_SIZE) {
-            throw new Error(`Invalid public key input. Expected ${PASSKEY_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
-        }
-    }
-    /**
-     * Checks if two passkey public keys are equal
-     */
-    equals(publicKey) {
-        return super.equals(publicKey);
-    }
-    /**
-     * Return the byte array representation of the Secp256r1 public key
-     */
-    toRawBytes() {
-        return this.data;
-    }
-    /**
-     * Return the Sui address associated with this Secp256r1 public key
-     */
-    flag() {
-        return SIGNATURE_SCHEME_TO_FLAG["Passkey"];
-    }
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
-    async verify(message, signature) {
-        const parsed = parseSerializedPasskeySignature(signature);
-        const clientDataJSON = JSON.parse(parsed.clientDataJson);
-        if (clientDataJSON.type !== "webauthn.get") {
-            return false;
-        }
-        // parse challenge from base64 url
-        const parsedChallenge = fromBase64(clientDataJSON.challenge.replace(/-/g, "+").replace(/_/g, "/"));
-        if (!bytesEqual(message, parsedChallenge)) {
-            return false;
-        }
-        const pk = parsed.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE);
-        if (!bytesEqual(this.toRawBytes(), pk)) {
-            return false;
-        }
-        const payload = new Uint8Array([
-            ...parsed.authenticatorData,
-            ...sha256(parsed.clientDataJson),
-        ]);
-        const sig = parsed.userSignature.slice(1, PASSKEY_SIGNATURE_SIZE + 1);
-        return secp256r1.verify(sig, sha256(payload), pk);
-    }
-}
-/**
- * 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 function parseDerSPKI(derBytes) {
-    // Verify length and header bytes are expected
-    if (derBytes.length !==
-        SECP256R1_SPKI_HEADER.length + PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE) {
-        throw new Error("Invalid DER length");
-    }
-    for (let i = 0; i < SECP256R1_SPKI_HEADER.length; i++) {
-        if (derBytes[i] !== SECP256R1_SPKI_HEADER[i]) {
-            throw new Error("Invalid spki header");
-        }
-    }
-    if (derBytes[SECP256R1_SPKI_HEADER.length] !== 0x04) {
-        throw new Error("Invalid point marker");
-    }
-    // Returns the last 65 bytes `04 || x || y`
-    return derBytes.slice(SECP256R1_SPKI_HEADER.length);
-}
-/**
- * Parse signature from bytes or base64 string into the following fields.
- */
-export function parseSerializedPasskeySignature(signature) {
-    const bytes = typeof signature === "string" ? fromBase64(signature) : signature;
-    if (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.Passkey) {
-        throw new Error("Invalid signature scheme");
-    }
-    const dec = PasskeyAuthenticator.parse(bytes.slice(1));
-    return {
-        signatureScheme: "Passkey",
-        serializedSignature: toBase64(bytes),
-        signature: bytes,
-        authenticatorData: dec.authenticatorData,
-        clientDataJson: dec.clientDataJson,
-        userSignature: new Uint8Array(dec.userSignature),
-        publicKey: new Uint8Array(dec.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE)),
-    };
-}
-//# sourceMappingURL=publickey.js.map
+import{fromBase64,toBase64}from'@mysten/bcs';import{secp256r1}from'@noble/curves/p256';import{sha256}from'@noble/hashes/sha256';import{PasskeyAuthenticator}from'../../bcs/bcs.js';import{bytesEqual,PublicKey}from'../../cryptography/publickey.js';import{SIGNATURE_SCHEME_TO_FLAG}from'../../cryptography/signature-scheme.js';export const PASSKEY_PUBLIC_KEY_SIZE=0x21;export const PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE=0x41;export const PASSKEY_SIGNATURE_SIZE=0x40;export const SECP256R1_SPKI_HEADER=new Uint8Array([0x30,0x59,0x30,0x13,0x6,0x7,0x2a,0x86,0x48,0xce,0x3d,0x2,0x1,0x6,0x8,0x2a,0x86,0x48,0xce,0x3d,0x3,0x1,0x7,0x3,0x42,0x0]);export class PasskeyPublicKey extends PublicKey{static ['SIZE']=PASSKEY_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']!==PASSKEY_PUBLIC_KEY_SIZE)throw new Error('Invalid\x20public\x20key\x20input.\x20Expected\x20'+PASSKEY_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['Passkey'];}async['verify'](a,b){const c=parseSerializedPasskeySignature(b),d=JSON['parse'](c['clientDataJson']);if(d['type']!=='webauthn.get')return![];const e=fromBase64(d['challenge']['replace'](/-/g,'+')['replace'](/_/g,'/'));if(!bytesEqual(a,e))return![];const f=c['userSignature']['slice'](0x1+PASSKEY_SIGNATURE_SIZE);if(!bytesEqual(this['toRawBytes'](),f))return![];const g=new Uint8Array([...c['authenticatorData'],...sha256(c['clientDataJson'])]),h=c['userSignature']['slice'](0x1,PASSKEY_SIGNATURE_SIZE+0x1);return secp256r1['verify'](h,sha256(g),f);}}export function parseDerSPKI(a){if(a['length']!==SECP256R1_SPKI_HEADER['length']+PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE)throw new Error('Invalid\x20DER\x20length');for(let b=0x0;b<SECP256R1_SPKI_HEADER['length'];b++){if(a[b]!==SECP256R1_SPKI_HEADER[b])throw new Error('Invalid\x20spki\x20header');}if(a[SECP256R1_SPKI_HEADER['length']]!==0x4)throw new Error('Invalid\x20point\x20marker');return a['slice'](SECP256R1_SPKI_HEADER['length']);}export function parseSerializedPasskeySignature(a){const b=typeof a==='string'?fromBase64(a):a;if(b[0x0]!==SIGNATURE_SCHEME_TO_FLAG['Passkey'])throw new Error('Invalid\x20signature\x20scheme');const c=PasskeyAuthenticator['parse'](b['slice'](0x1));return{'signatureScheme':'Passkey','serializedSignature':toBase64(b),'signature':b,'authenticatorData':c['authenticatorData'],'clientDataJson':c['clientDataJson'],'userSignature':new Uint8Array(c['userSignature']),'publicKey':new Uint8Array(c['userSignature']['slice'](0x1+PASSKEY_SIGNATURE_SIZE))};}

package/dist/esm/keypairs/passkey/types.d.ts

@@ -1,12 +1,6 @@
-/**
- * The value returned from navigator.credentials.get()
- */
 export interface AuthenticationCredential extends PublicKeyCredential {
     response: AuthenticatorAssertionResponse;
 }
-/**
- * The value returned from navigator.credentials.create()
- */
 export interface RegistrationCredential extends PublicKeyCredential {
     response: AuthenticatorAttestationResponse;
 }

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

@@ -1,4 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-export {};
-//# sourceMappingURL=types.js.map
+export{};

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

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

package/dist/esm/keypairs/secp256k1/keypair.d.ts

@@ -2,72 +2,21 @@ import { Keypair } from "../../cryptography/keypair.js";
 import type { PublicKey } from "../../cryptography/publickey.js";
 import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
 export declare const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
-/**
- * Secp256k1 Keypair data
- */
 export interface Secp256k1KeypairData {
     publicKey: Uint8Array;
     secretKey: Uint8Array;
 }
-/**
- * An Secp256k1 Keypair used for signing transactions.
- */
 export declare class Secp256k1Keypair extends Keypair {
     private keypair;
-    /**
-     * Create a new keypair instance.
-     * Generate random keypair if no {@link Secp256k1Keypair} is provided.
-     *
-     * @param keypair secp256k1 keypair
-     */
     constructor(keypair?: Secp256k1KeypairData);
-    /**
-     * Get the key scheme of the keypair Secp256k1
-     */
     getKeyScheme(): SignatureScheme;
-    /**
-     * Generate a new random keypair
-     */
     static generate(): Secp256k1Keypair;
-    /**
-     * Create a keypair from a raw secret key byte array.
-     *
-     * This method should only be used to recreate a keypair from a previously
-     * generated secret key. Generating keypairs from a random seed should be done
-     * with the {@link Keypair.fromSeed} method.
-     *
-     * @throws error if the provided secret key is invalid and validation is not skipped.
-     *
-     * @param secretKey secret key byte array  or Bech32 secret key string
-     * @param options: skip secret key validation
-     */
     static fromSecretKey(secretKey: Uint8Array | string, options?: {
         skipValidation?: boolean;
     }): Secp256k1Keypair;
-    /**
-     * Generate a keypair from a 32 byte seed.
-     *
-     * @param seed seed byte array
-     */
     static fromSeed(seed: Uint8Array): Secp256k1Keypair;
-    /**
-     * The public key for this keypair
-     */
     getPublicKey(): PublicKey;
-    /**
-     * The Bech32 secret key string for this Secp256k1 keypair
-     */
     getSecretKey(): string;
-    /**
-     * Return the signature for the provided data.
-     */
     sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    /**
-     * Derive Secp256k1 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/54'/784'/0'/0/0, otherwise the path must
-     * be compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}.
-     */
     static deriveKeypair(mnemonics: string, path?: string): Secp256k1Keypair;
 }