wowok 2.1.40 → 2.1.41

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

@@ -1,90 +1 @@
-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'";
-export class Ed25519Keypair extends Keypair {
-    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,
-            };
-        }
-    }
-    getKeyScheme() {
-        return "ED25519";
-    }
-    static generate() {
-        const secretKey = ed25519.utils.randomPrivateKey();
-        return new Ed25519Keypair({
-            publicKey: ed25519.getPublicKey(secretKey),
-            secretKey,
-        });
-    }
-    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);
-    }
-    getPublicKey() {
-        return new Ed25519PublicKey(this.keypair.publicKey);
-    }
-    getSecretKey() {
-        return encodeWowPrivateKey(this.keypair.secretKey.slice(0, PRIVATE_KEY_SIZE), this.getKeyScheme());
-    }
-    async sign(data) {
-        return ed25519.sign(data, this.keypair.secretKey);
-    }
-    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);
-    }
-    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);
-    }
-}
+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.js

@@ -1,50 +1 @@
-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;
-export class Ed25519PublicKey extends PublicKey {
-    static SIZE = PUBLIC_KEY_SIZE;
-    data;
-    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}`);
-        }
-    }
-    equals(publicKey) {
-        return super.equals(publicKey);
-    }
-    toRawBytes() {
-        return this.data;
-    }
-    flag() {
-        return SIGNATURE_SCHEME_TO_FLAG["ED25519"];
-    }
-    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());
-    }
-}
+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,4 +1 @@
-export * from "./ed25519/index.js";
-export * from "./passkey/index.js";
-export * from "./secp256k1/index.js";
-export * from "./secp256r1/index.js";
+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,2 +1 @@
-export { PasskeyKeypair, BrowserPasskeyProvider, findCommonPublicKey, } from "./keypair.js";
-export { PasskeyPublicKey } from "./publickey.js";
+export{PasskeyKeypair,BrowserPasskeyProvider,findCommonPublicKey}from'./keypair.js';export{PasskeyPublicKey}from'./publickey.js';

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

@@ -1,155 +1 @@
-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(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,
-            },
-        }));
-    }
-}
-export class PasskeyKeypair extends Signer {
-    publicKey;
-    provider;
-    getKeyScheme() {
-        return "Passkey";
-    }
-    constructor(publicKey, provider) {
-        super();
-        this.publicKey = publicKey;
-        this.provider = provider;
-    }
-    static async getPasskeyInstance(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);
-        }
-    }
-    getPublicKey() {
-        return new PasskeyPublicKey(this.publicKey);
-    }
-    async sign(data) {
-        const credential = await this.provider.get(data);
-        const authenticatorData = new Uint8Array(credential.response.authenticatorData);
-        const clientDataJSON = new Uint8Array(credential.response.clientDataJSON);
-        const decoder = new TextDecoder();
-        const clientDataJSONString = decoder.decode(clientDataJSON);
-        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");
-        }
-        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);
-        return PasskeyAuthenticator.serialize({
-            authenticatorData: authenticatorData,
-            clientDataJson: clientDataJSONString,
-            userSignature: arr,
-        }).toBytes();
-    }
-    async signWithIntent(bytes, intent) {
-        const intentMessage = messageWithIntent(intent, bytes);
-        const digest = blake2b(intentMessage, { dkLen: 32 });
-        const signature = await this.sign(digest);
-        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),
-        };
-    }
-    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;
-    }
-}
-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];
-}
-function messageFromAssertionResponse(response) {
-    const authenticatorData = new Uint8Array(response.authenticatorData);
-    const clientDataJSON = new Uint8Array(response.clientDataJSON);
-    const clientDataJSONDigest = sha256(clientDataJSON);
-    return new Uint8Array([...authenticatorData, ...clientDataJSONDigest]);
-}
+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.js

@@ -1,117 +1 @@
-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;
-export const SECP256R1_SPKI_HEADER = new Uint8Array([
-    0x30,
-    0x59,
-    0x30,
-    0x13,
-    0x06,
-    0x07,
-    0x2a,
-    0x86,
-    0x48,
-    0xce,
-    0x3d,
-    0x02,
-    0x01,
-    0x06,
-    0x08,
-    0x2a,
-    0x86,
-    0x48,
-    0xce,
-    0x3d,
-    0x03,
-    0x01,
-    0x07,
-    0x03,
-    0x42,
-    0x00,
-]);
-export class PasskeyPublicKey extends PublicKey {
-    static SIZE = PASSKEY_PUBLIC_KEY_SIZE;
-    data;
-    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}`);
-        }
-    }
-    equals(publicKey) {
-        return super.equals(publicKey);
-    }
-    toRawBytes() {
-        return this.data;
-    }
-    flag() {
-        return SIGNATURE_SCHEME_TO_FLAG["Passkey"];
-    }
-    async verify(message, signature) {
-        const parsed = parseSerializedPasskeySignature(signature);
-        const clientDataJSON = JSON.parse(parsed.clientDataJson);
-        if (clientDataJSON.type !== "webauthn.get") {
-            return false;
-        }
-        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);
-    }
-}
-export function parseDerSPKI(derBytes) {
-    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");
-    }
-    return derBytes.slice(SECP256R1_SPKI_HEADER.length);
-}
-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)),
-    };
-}
+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.js

@@ -1 +1 @@
-export {};
+export{};

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

@@ -1,2 +1 @@
-export { DEFAULT_SECP256K1_DERIVATION_PATH, Secp256k1Keypair, } from "./keypair.js";
-export { Secp256k1PublicKey } from "./publickey.js";
+export{DEFAULT_SECP256K1_DERIVATION_PATH,Secp256k1Keypair}from'./keypair.js';export{Secp256k1PublicKey}from'./publickey.js';

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

@@ -1,82 +1 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { blake2b } from "@noble/hashes/blake2b";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex } from "@noble/hashes/utils";
-import { HDKey } from "@scure/bip32";
-import { decodeWowPrivateKey, encodeWowPrivateKey, Keypair, } from "../../cryptography/keypair.js";
-import { isValidBIP32Path, mnemonicToSeed, } from "../../cryptography/mnemonics.js";
-import { Secp256k1PublicKey } from "./publickey.js";
-export const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
-export class Secp256k1Keypair extends Keypair {
-    keypair;
-    constructor(keypair) {
-        super();
-        if (keypair) {
-            this.keypair = keypair;
-        }
-        else {
-            const secretKey = secp256k1.utils.randomPrivateKey();
-            const publicKey = secp256k1.getPublicKey(secretKey, true);
-            this.keypair = { publicKey, secretKey };
-        }
-    }
-    getKeyScheme() {
-        return "Secp256k1";
-    }
-    static generate() {
-        return new Secp256k1Keypair();
-    }
-    static fromSecretKey(secretKey, options) {
-        if (typeof secretKey === "string") {
-            const decoded = decodeWowPrivateKey(secretKey);
-            if (decoded.scheme !== "Secp256k1") {
-                throw new Error(`Expected a Secp256k1 keypair, got ${decoded.scheme}`);
-            }
-            return this.fromSecretKey(decoded.secretKey, options);
-        }
-        const publicKey = secp256k1.getPublicKey(secretKey, true);
-        if (!options || !options.skipValidation) {
-            const encoder = new TextEncoder();
-            const signData = encoder.encode("sui validation");
-            const msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));
-            const signature = secp256k1.sign(msgHash, secretKey);
-            if (!secp256k1.verify(signature, msgHash, publicKey, { lowS: true })) {
-                throw new Error("Provided secretKey is invalid");
-            }
-        }
-        return new Secp256k1Keypair({ publicKey, secretKey });
-    }
-    static fromSeed(seed) {
-        const publicKey = secp256k1.getPublicKey(seed, true);
-        return new Secp256k1Keypair({ publicKey, secretKey: seed });
-    }
-    getPublicKey() {
-        return new Secp256k1PublicKey(this.keypair.publicKey);
-    }
-    getSecretKey() {
-        return encodeWowPrivateKey(this.keypair.secretKey, this.getKeyScheme());
-    }
-    async sign(data) {
-        const msgHash = sha256(data);
-        const sig = secp256k1.sign(msgHash, this.keypair.secretKey, {
-            lowS: true,
-        });
-        return sig.toCompactRawBytes();
-    }
-    static deriveKeypair(mnemonics, path) {
-        if (path == null) {
-            path = DEFAULT_SECP256K1_DERIVATION_PATH;
-        }
-        if (!isValidBIP32Path(path)) {
-            throw new Error("Invalid derivation path");
-        }
-        const key = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path);
-        if (key.publicKey == null || key.privateKey == null) {
-            throw new Error("Invalid key");
-        }
-        return new Secp256k1Keypair({
-            publicKey: key.publicKey,
-            secretKey: key.privateKey,
-        });
-    }
-}
+import{secp256k1}from'@noble/curves/secp256k1';import{blake2b}from'@noble/hashes/blake2b';import{sha256}from'@noble/hashes/sha256';import{bytesToHex}from'@noble/hashes/utils';import{HDKey}from'@scure/bip32';import{decodeWowPrivateKey,encodeWowPrivateKey,Keypair}from'../../cryptography/keypair.js';import{isValidBIP32Path,mnemonicToSeed}from'../../cryptography/mnemonics.js';import{Secp256k1PublicKey}from'./publickey.js';export const DEFAULT_SECP256K1_DERIVATION_PATH='m/54\x27/784\x27/0\x27/0/0';export class Secp256k1Keypair extends Keypair{['keypair'];constructor(a){super();if(a)this['keypair']=a;else{const b=secp256k1['utils']['randomPrivateKey'](),c=secp256k1['getPublicKey'](b,!![]);this['keypair']={'publicKey':c,'secretKey':b};}}['getKeyScheme'](){return'Secp256k1';}static['generate'](){return new Secp256k1Keypair();}static['fromSecretKey'](a,b){if(typeof a==='string'){const d=decodeWowPrivateKey(a);if(d['scheme']!=='Secp256k1')throw new Error('Expected\x20a\x20Secp256k1\x20keypair,\x20got\x20'+d['scheme']);return this['fromSecretKey'](d['secretKey'],b);}const c=secp256k1['getPublicKey'](a,!![]);if(!b||!b['skipValidation']){const e=new TextEncoder(),f=e['encode']('sui\x20validation'),g=bytesToHex(blake2b(f,{'dkLen':0x20})),h=secp256k1['sign'](g,a);if(!secp256k1['verify'](h,g,c,{'lowS':!![]}))throw new Error('Provided\x20secretKey\x20is\x20invalid');}return new Secp256k1Keypair({'publicKey':c,'secretKey':a});}static['fromSeed'](a){const b=secp256k1['getPublicKey'](a,!![]);return new Secp256k1Keypair({'publicKey':b,'secretKey':a});}['getPublicKey'](){return new Secp256k1PublicKey(this['keypair']['publicKey']);}['getSecretKey'](){return encodeWowPrivateKey(this['keypair']['secretKey'],this['getKeyScheme']());}async['sign'](a){const b=sha256(a),c=secp256k1['sign'](b,this['keypair']['secretKey'],{'lowS':!![]});return c['toCompactRawBytes']();}static['deriveKeypair'](a,b){b==null&&(b=DEFAULT_SECP256K1_DERIVATION_PATH);if(!isValidBIP32Path(b))throw new Error('Invalid\x20derivation\x20path');const c=HDKey['fromMasterSeed'](mnemonicToSeed(a))['derive'](b);if(c['publicKey']==null||c['privateKey']==null)throw new Error('Invalid\x20key');return new Secp256k1Keypair({'publicKey':c['publicKey'],'secretKey':c['privateKey']});}}

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

@@ -1,51 +1 @@
-import { fromBase64 } from "@mysten/bcs";
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesEqual, parseSerializedKeypairSignature, PublicKey, } from "../../cryptography/publickey.js";
-import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.js";
-const SECP256K1_PUBLIC_KEY_SIZE = 33;
-export class Secp256k1PublicKey extends PublicKey {
-    static SIZE = SECP256K1_PUBLIC_KEY_SIZE;
-    data;
-    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 !== SECP256K1_PUBLIC_KEY_SIZE) {
-            throw new Error(`Invalid public key input. Expected ${SECP256K1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
-        }
-    }
-    equals(publicKey) {
-        return super.equals(publicKey);
-    }
-    toRawBytes() {
-        return this.data;
-    }
-    flag() {
-        return SIGNATURE_SCHEME_TO_FLAG["Secp256k1"];
-    }
-    async verify(message, signature) {
-        let bytes;
-        if (typeof signature === "string") {
-            const parsed = parseSerializedKeypairSignature(signature);
-            if (parsed.signatureScheme !== "Secp256k1") {
-                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 secp256k1.verify(secp256k1.Signature.fromCompact(bytes), sha256(message), this.toRawBytes());
-    }
-}
+import{fromBase64}from'@mysten/bcs';import{secp256k1}from'@noble/curves/secp256k1';import{sha256}from'@noble/hashes/sha256';import{bytesEqual,parseSerializedKeypairSignature,PublicKey}from'../../cryptography/publickey.js';import{SIGNATURE_SCHEME_TO_FLAG}from'../../cryptography/signature-scheme.js';const SECP256K1_PUBLIC_KEY_SIZE=0x21;export class Secp256k1PublicKey extends PublicKey{static ['SIZE']=SECP256K1_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']!==SECP256K1_PUBLIC_KEY_SIZE)throw new Error('Invalid\x20public\x20key\x20input.\x20Expected\x20'+SECP256K1_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['Secp256k1'];}async['verify'](a,b){let c;if(typeof b==='string'){const d=parseSerializedKeypairSignature(b);if(d['signatureScheme']!=='Secp256k1')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 secp256k1['verify'](secp256k1['Signature']['fromCompact'](c),sha256(a),this['toRawBytes']());}}

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

@@ -1,2 +1 @@
-export { DEFAULT_SECP256R1_DERIVATION_PATH, Secp256r1Keypair, } from "./keypair.js";
-export { Secp256r1PublicKey } from "./publickey.js";
+export{DEFAULT_SECP256R1_DERIVATION_PATH,Secp256r1Keypair}from'./keypair.js';export{Secp256r1PublicKey}from'./publickey.js';