wowok 2.2.3 → 2.2.5

package/dist/esm/keypairs/ed25519/ed25519-hd-key.d.ts

@@ -1,8 +0,0 @@
-type Hex = string;
-type Path = string;
-type Keys = {
-    key: Uint8Array;
-    chainCode: Uint8Array;
-};
-export declare const derivePath: (path: Path, seed: Hex, offset?: number) => Keys;
-export {};

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

@@ -1 +0,0 @@
-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.d.ts

@@ -1,2 +0,0 @@
-export { DEFAULT_ED25519_DERIVATION_PATH, Ed25519Keypair, type Ed25519KeypairData, } from "./keypair.js";
-export { Ed25519PublicKey } from "./publickey.js";

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

@@ -1 +0,0 @@
-export{DEFAULT_ED25519_DERIVATION_PATH,Ed25519Keypair}from'./keypair.js';export{Ed25519PublicKey}from'./publickey.js';

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

@@ -1,22 +0,0 @@
-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'";
-export interface Ed25519KeypairData {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
-}
-export declare class Ed25519Keypair extends Keypair {
-    private keypair;
-    constructor(keypair?: Ed25519KeypairData);
-    getKeyScheme(): SignatureScheme;
-    static generate(): Ed25519Keypair;
-    static fromSecretKey(secretKey: Uint8Array | string, options?: {
-        skipValidation?: boolean;
-    }): Ed25519Keypair;
-    getPublicKey(): Ed25519PublicKey;
-    getSecretKey(): string;
-    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    static deriveKeypair(mnemonics: string, path?: string): Ed25519Keypair;
-    static deriveKeypairFromSeed(seedHex: string, path?: string): Ed25519Keypair;
-}

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

@@ -1 +0,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\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 +0,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=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/passkey/index.d.ts

@@ -1,3 +0,0 @@
-export { PasskeyKeypair, BrowserPasskeyProvider, findCommonPublicKey, } from "./keypair.js";
-export type { PasskeyProvider, BrowserPasswordProviderOptions, } from "./keypair.js";
-export { PasskeyPublicKey } from "./publickey.js";

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

@@ -1 +0,0 @@
-export{PasskeyKeypair,BrowserPasskeyProvider,findCommonPublicKey}from'./keypair.js';export{PasskeyPublicKey}from'./publickey.js';

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

@@ -1,33 +0,0 @@
-import type { IntentScope, SignatureWithBytes } from "../../cryptography/index.js";
-import { Signer } from "../../cryptography/index.js";
-import type { PublicKey } from "../../cryptography/publickey.js";
-import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
-import type { AuthenticationCredential, RegistrationCredential } from "./types.js";
-type DeepPartialConfigKeys = "rp" | "user" | "authenticatorSelection";
-type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-export type BrowserPasswordProviderOptions = Pick<DeepPartial<PublicKeyCredentialCreationOptions>, DeepPartialConfigKeys> & Omit<Partial<PublicKeyCredentialCreationOptions>, DeepPartialConfigKeys | "pubKeyCredParams" | "challenge">;
-export interface PasskeyProvider {
-    create(): Promise<RegistrationCredential>;
-    get(challenge: Uint8Array): Promise<AuthenticationCredential>;
-}
-export declare class BrowserPasskeyProvider implements PasskeyProvider {
-    #private;
-    constructor(name: string, options: BrowserPasswordProviderOptions);
-    create(): Promise<RegistrationCredential>;
-    get(challenge: Uint8Array): Promise<AuthenticationCredential>;
-}
-export declare class PasskeyKeypair extends Signer {
-    private publicKey;
-    private provider;
-    getKeyScheme(): SignatureScheme;
-    constructor(publicKey: Uint8Array, provider: PasskeyProvider);
-    static getPasskeyInstance(provider: PasskeyProvider): Promise<PasskeyKeypair>;
-    getPublicKey(): PublicKey;
-    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes>;
-    static signAndRecover(provider: PasskeyProvider, message: Uint8Array): Promise<PublicKey[]>;
-}
-export declare function findCommonPublicKey(arr1: PublicKey[], arr2: PublicKey[]): PublicKey;
-export {};

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

@@ -1 +0,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';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

@@ -1,25 +0,0 @@
-import { PublicKey } from "../../cryptography/publickey.js";
-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;
-export declare const SECP256R1_SPKI_HEADER: Uint8Array<ArrayBuffer>;
-export declare class PasskeyPublicKey extends PublicKey {
-    static SIZE: number;
-    private data;
-    constructor(value: PublicKeyInitData);
-    equals(publicKey: PasskeyPublicKey): boolean;
-    toRawBytes(): Uint8Array<ArrayBuffer>;
-    flag(): number;
-    verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
-}
-export declare function parseDerSPKI(derBytes: Uint8Array): Uint8Array;
-export declare function parseSerializedPasskeySignature(signature: Uint8Array | string): {
-    signatureScheme: "Passkey";
-    serializedSignature: string;
-    signature: Uint8Array<ArrayBufferLike>;
-    authenticatorData: Uint8Array<ArrayBufferLike>;
-    clientDataJson: string;
-    userSignature: Uint8Array<ArrayBuffer>;
-    publicKey: Uint8Array<ArrayBuffer>;
-};

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

@@ -1 +0,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=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,6 +0,0 @@
-export interface AuthenticationCredential extends PublicKeyCredential {
-    response: AuthenticatorAssertionResponse;
-}
-export interface RegistrationCredential extends PublicKeyCredential {
-    response: AuthenticatorAttestationResponse;
-}

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

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

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

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

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

@@ -1,22 +0,0 @@
-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";
-export interface Secp256k1KeypairData {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
-}
-export declare class Secp256k1Keypair extends Keypair {
-    private keypair;
-    constructor(keypair?: Secp256k1KeypairData);
-    getKeyScheme(): SignatureScheme;
-    static generate(): Secp256k1Keypair;
-    static fromSecretKey(secretKey: Uint8Array | string, options?: {
-        skipValidation?: boolean;
-    }): Secp256k1Keypair;
-    static fromSeed(seed: Uint8Array): Secp256k1Keypair;
-    getPublicKey(): PublicKey;
-    getSecretKey(): string;
-    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    static deriveKeypair(mnemonics: string, path?: string): Secp256k1Keypair;
-}

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

@@ -1 +0,0 @@
-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.d.ts

@@ -1,11 +0,0 @@
-import { PublicKey } from "../../cryptography/publickey.js";
-import type { PublicKeyInitData } from "../../cryptography/publickey.js";
-export declare class Secp256k1PublicKey extends PublicKey {
-    static SIZE: number;
-    private data;
-    constructor(value: PublicKeyInitData);
-    equals(publicKey: Secp256k1PublicKey): boolean;
-    toRawBytes(): Uint8Array<ArrayBuffer>;
-    flag(): number;
-    verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
-}

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

@@ -1 +0,0 @@
-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.d.ts

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

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

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

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

@@ -1,22 +0,0 @@
-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_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
-export interface Secp256r1KeypairData {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
-}
-export declare class Secp256r1Keypair extends Keypair {
-    private keypair;
-    constructor(keypair?: Secp256r1KeypairData);
-    getKeyScheme(): SignatureScheme;
-    static generate(): Secp256r1Keypair;
-    static fromSecretKey(secretKey: Uint8Array | string, options?: {
-        skipValidation?: boolean;
-    }): Secp256r1Keypair;
-    static fromSeed(seed: Uint8Array): Secp256r1Keypair;
-    getPublicKey(): PublicKey;
-    getSecretKey(): string;
-    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    static deriveKeypair(mnemonics: string, path?: string): Secp256r1Keypair;
-}

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

@@ -1 +0,0 @@
-import{secp256r1}from'@noble/curves/p256';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{Secp256r1PublicKey}from'./publickey.js';export const DEFAULT_SECP256R1_DERIVATION_PATH='m/74\x27/784\x27/0\x27/0/0';export class Secp256r1Keypair extends Keypair{['keypair'];constructor(a){super();if(a)this['keypair']=a;else{const b=secp256r1['utils']['randomPrivateKey'](),c=secp256r1['getPublicKey'](b,!![]);this['keypair']={'publicKey':c,'secretKey':b};}}['getKeyScheme'](){return'Secp256r1';}static['generate'](){return new Secp256r1Keypair();}static['fromSecretKey'](a,b){if(typeof a==='string'){const d=decodeWowPrivateKey(a);if(d['scheme']!=='Secp256r1')throw new Error('Expected\x20a\x20Secp256r1\x20keypair,\x20got\x20'+d['scheme']);return this['fromSecretKey'](d['secretKey'],b);}const c=secp256r1['getPublicKey'](a,!![]);if(!b||!b['skipValidation']){const e=new TextEncoder(),f=e['encode']('sui\x20validation'),g=bytesToHex(blake2b(f,{'dkLen':0x20})),h=secp256r1['sign'](g,a,{'lowS':!![]});if(!secp256r1['verify'](h,g,c,{'lowS':!![]}))throw new Error('Provided\x20secretKey\x20is\x20invalid');}return new Secp256r1Keypair({'publicKey':c,'secretKey':a});}static['fromSeed'](a){const b=secp256r1['getPublicKey'](a,!![]);return new Secp256r1Keypair({'publicKey':b,'secretKey':a});}['getPublicKey'](){return new Secp256r1PublicKey(this['keypair']['publicKey']);}['getSecretKey'](){return encodeWowPrivateKey(this['keypair']['secretKey'],this['getKeyScheme']());}async['sign'](a){const b=sha256(a),c=secp256r1['sign'](b,this['keypair']['secretKey'],{'lowS':!![]});return c['toCompactRawBytes']();}static['deriveKeypair'](a,b){b==null&&(b=DEFAULT_SECP256R1_DERIVATION_PATH);if(!isValidBIP32Path(b))throw new Error('Invalid\x20derivation\x20path');const c=HDKey['fromMasterSeed'](mnemonicToSeed(a))['derive'](b)['privateKey'];return Secp256r1Keypair['fromSecretKey'](c);}}

package/dist/esm/keypairs/secp256r1/publickey.d.ts

@@ -1,11 +0,0 @@
-import { PublicKey } from "../../cryptography/publickey.js";
-import type { PublicKeyInitData } from "../../cryptography/publickey.js";
-export declare class Secp256r1PublicKey extends PublicKey {
-    static SIZE: number;
-    private data;
-    constructor(value: PublicKeyInitData);
-    equals(publicKey: Secp256r1PublicKey): boolean;
-    toRawBytes(): Uint8Array<ArrayBuffer>;
-    flag(): number;
-    verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
-}

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

@@ -1 +0,0 @@
-import{fromBase64}from'@mysten/bcs';import{secp256r1}from'@noble/curves/p256';import{sha256}from'@noble/hashes/sha256';import{bytesEqual,PublicKey}from'../../cryptography/publickey.js';import{SIGNATURE_SCHEME_TO_FLAG}from'../../cryptography/signature-scheme.js';import{parseSerializedSignature}from'../../cryptography/signature.js';const SECP256R1_PUBLIC_KEY_SIZE=0x21;export class Secp256r1PublicKey extends PublicKey{static ['SIZE']=SECP256R1_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']!==SECP256R1_PUBLIC_KEY_SIZE)throw new Error('Invalid\x20public\x20key\x20input.\x20Expected\x20'+SECP256R1_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['Secp256r1'];}async['verify'](a,b){let c;if(typeof b==='string'){const d=parseSerializedSignature(b);if(d['signatureScheme']!=='Secp256r1')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 secp256r1['verify'](secp256r1['Signature']['fromCompact'](c),sha256(a),this['toRawBytes']());}}

package/dist/esm/utils/suins.d.ts

@@ -1,2 +0,0 @@
-export declare function isValidSuiNSName(name: string): boolean;
-export declare function normalizeSuiNSName(name: string, format?: "at" | "dot"): string;

package/dist/esm/utils/suins.js

@@ -1 +0,0 @@
-const SUI_NS_NAME_REGEX=/^(?!.*(^(?!@)|[-.@])($|[-.@]))(?:[a-z0-9-]{0,63}(?:\.[a-z0-9-]{0,63})*)?@[a-z0-9-]{0,63}$/i,SUI_NS_DOMAIN_REGEX=/^(?!.*(^|[-.])($|[-.]))(?:[a-z0-9-]{0,63}\.)+sui$/i,MAX_SUI_NS_NAME_LENGTH=0xeb;export function isValidSuiNSName(a){if(a['length']>MAX_SUI_NS_NAME_LENGTH)return![];if(a['includes']('@'))return SUI_NS_NAME_REGEX['test'](a);return SUI_NS_DOMAIN_REGEX['test'](a);}export function normalizeSuiNSName(a,b='at'){const c=a['toLowerCase']();let d;if(c['includes']('@')){if(!SUI_NS_NAME_REGEX['test'](c))throw new Error('Invalid\x20SuiNS\x20name\x20'+a);const [e,f]=c['split']('@');d=[...e?e['split']('.'):[],f];}else{if(!SUI_NS_DOMAIN_REGEX['test'](c))throw new Error('Invalid\x20SuiNS\x20name\x20'+a);d=c['split']('.')['slice'](0x0,-0x1);}if(b==='dot')return d['join']('.')+'.sui';return d['slice'](0x0,-0x1)['join']('.')+'@'+d[d['length']-0x1];}