wowok 2.1.39 → 2.1.41

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

@@ -1,133 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.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'/784'/0'/0/0";
-/**
- * An Secp256k1 Keypair used for signing transactions.
- */
-export class Secp256k1Keypair extends Keypair {
-    keypair;
-    /**
-     * Create a new keypair instance.
-     * Generate random keypair if no {@link Secp256k1Keypair} is provided.
-     *
-     * @param keypair secp256k1 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 };
-        }
-    }
-    /**
-     * Get the key scheme of the keypair Secp256k1
-     */
-    getKeyScheme() {
-        return "Secp256k1";
-    }
-    /**
-     * Generate a new random keypair
-     */
-    static generate() {
-        return new 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, 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 });
-    }
-    /**
-     * Generate a keypair from a 32 byte seed.
-     *
-     * @param seed seed byte array
-     */
-    static fromSeed(seed) {
-        const publicKey = secp256k1.getPublicKey(seed, true);
-        return new Secp256k1Keypair({ publicKey, secretKey: seed });
-    }
-    /**
-     * The public key for this keypair
-     */
-    getPublicKey() {
-        return new Secp256k1PublicKey(this.keypair.publicKey);
-    }
-    /**
-     * The Bech32 secret key string for this Secp256k1 keypair
-     */
-    getSecretKey() {
-        return encodeWowPrivateKey(this.keypair.secretKey, this.getKeyScheme());
-    }
-    /**
-     * Return the signature for the provided data.
-     */
-    async sign(data) {
-        const msgHash = sha256(data);
-        const sig = secp256k1.sign(msgHash, this.keypair.secretKey, {
-            lowS: true,
-        });
-        return sig.toCompactRawBytes();
-    }
-    /**
-     * 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, 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,
-        });
-    }
-}
-//# sourceMappingURL=keypair.js.map
+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,30 +1,11 @@
 import { PublicKey } from "../../cryptography/publickey.js";
 import type { PublicKeyInitData } from "../../cryptography/publickey.js";
-/**
- * A Secp256k1 public key
- */
 export declare class Secp256k1PublicKey extends PublicKey {
     static SIZE: number;
     private data;
-    /**
-     * Create a new Secp256k1PublicKey object
-     * @param value secp256k1 public key as buffer or base-64 encoded string
-     */
     constructor(value: PublicKeyInitData);
-    /**
-     * Checks if two Secp256k1 public keys are equal
-     */
     equals(publicKey: Secp256k1PublicKey): boolean;
-    /**
-     * Return the byte array representation of the Secp256k1 public key
-     */
     toRawBytes(): Uint8Array<ArrayBuffer>;
-    /**
-     * Return the Sui address associated with this Secp256k1 public key
-     */
     flag(): number;
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
     verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
 }

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

@@ -1,73 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.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 = 33;
-/**
- * A Secp256k1 public key
- */
-export class Secp256k1PublicKey extends PublicKey {
-    static SIZE = SECP256K1_PUBLIC_KEY_SIZE;
-    data;
-    /**
-     * Create a new Secp256k1PublicKey object
-     * @param value secp256k1 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 !== SECP256K1_PUBLIC_KEY_SIZE) {
-            throw new Error(`Invalid public key input. Expected ${SECP256K1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
-        }
-    }
-    /**
-     * Checks if two Secp256k1 public keys are equal
-     */
-    equals(publicKey) {
-        return super.equals(publicKey);
-    }
-    /**
-     * Return the byte array representation of the Secp256k1 public key
-     */
-    toRawBytes() {
-        return this.data;
-    }
-    /**
-     * Return the Sui address associated with this Secp256k1 public key
-     */
-    flag() {
-        return SIGNATURE_SCHEME_TO_FLAG["Secp256k1"];
-    }
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
-    async verify(message, signature) {
-        let bytes;
-        if (typeof signature === "string") {
-            const parsed = parseSerializedKeypairSignature(signature);
-            if (parsed.signatureScheme !== "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());
-    }
-}
-//# sourceMappingURL=publickey.js.map
+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,5 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-export { DEFAULT_SECP256R1_DERIVATION_PATH, Secp256r1Keypair, } from "./keypair.js";
-export { Secp256r1PublicKey } from "./publickey.js";
-//# sourceMappingURL=index.js.map
+export{DEFAULT_SECP256R1_DERIVATION_PATH,Secp256r1Keypair}from'./keypair.js';export{Secp256r1PublicKey}from'./publickey.js';

package/dist/esm/keypairs/secp256r1/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_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
-/**
- * Secp256r1 Keypair data
- */
 export interface Secp256r1KeypairData {
     publicKey: Uint8Array;
     secretKey: Uint8Array;
 }
-/**
- * An Secp256r1 Keypair used for signing transactions.
- */
 export declare class Secp256r1Keypair extends Keypair {
     private keypair;
-    /**
-     * Create a new keypair instance.
-     * Generate random keypair if no {@link Secp256r1Keypair} is provided.
-     *
-     * @param keypair Secp256r1 keypair
-     */
     constructor(keypair?: Secp256r1KeypairData);
-    /**
-     * Get the key scheme of the keypair Secp256r1
-     */
     getKeyScheme(): SignatureScheme;
-    /**
-     * Generate a new random keypair
-     */
     static generate(): Secp256r1Keypair;
-    /**
-     * 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;
     }): Secp256r1Keypair;
-    /**
-     * Generate a keypair from a 32 byte seed.
-     *
-     * @param seed seed byte array
-     */
     static fromSeed(seed: Uint8Array): Secp256r1Keypair;
-    /**
-     * The public key for this keypair
-     */
     getPublicKey(): PublicKey;
-    /**
-     * The Bech32 secret key string for this Secp256r1 keypair
-     */
     getSecretKey(): string;
-    /**
-     * Return the signature for the provided data.
-     */
     sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
-    /**
-     * Derive Secp256r1 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/74'/784'/0'/0/0, otherwise the path must
-     * be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.
-     */
     static deriveKeypair(mnemonics: string, path?: string): Secp256r1Keypair;
 }

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

@@ -1,130 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.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'/784'/0'/0/0";
-/**
- * An Secp256r1 Keypair used for signing transactions.
- */
-export class Secp256r1Keypair extends Keypair {
-    keypair;
-    /**
-     * Create a new keypair instance.
-     * Generate random keypair if no {@link Secp256r1Keypair} is provided.
-     *
-     * @param keypair Secp256r1 keypair
-     */
-    constructor(keypair) {
-        super();
-        if (keypair) {
-            this.keypair = keypair;
-        }
-        else {
-            const secretKey = secp256r1.utils.randomPrivateKey();
-            const publicKey = secp256r1.getPublicKey(secretKey, true);
-            this.keypair = { publicKey, secretKey };
-        }
-    }
-    /**
-     * Get the key scheme of the keypair Secp256r1
-     */
-    getKeyScheme() {
-        return "Secp256r1";
-    }
-    /**
-     * Generate a new random keypair
-     */
-    static generate() {
-        return new Secp256r1Keypair();
-    }
-    /**
-     * 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, options) {
-        if (typeof secretKey === "string") {
-            const decoded = decodeWowPrivateKey(secretKey);
-            if (decoded.scheme !== "Secp256r1") {
-                throw new Error(`Expected a Secp256r1 keypair, got ${decoded.scheme}`);
-            }
-            return this.fromSecretKey(decoded.secretKey, options);
-        }
-        const publicKey = secp256r1.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 = secp256r1.sign(msgHash, secretKey, {
-                lowS: true,
-            });
-            if (!secp256r1.verify(signature, msgHash, publicKey, { lowS: true })) {
-                throw new Error("Provided secretKey is invalid");
-            }
-        }
-        return new Secp256r1Keypair({ publicKey, secretKey });
-    }
-    /**
-     * Generate a keypair from a 32 byte seed.
-     *
-     * @param seed seed byte array
-     */
-    static fromSeed(seed) {
-        const publicKey = secp256r1.getPublicKey(seed, true);
-        return new Secp256r1Keypair({ publicKey, secretKey: seed });
-    }
-    /**
-     * The public key for this keypair
-     */
-    getPublicKey() {
-        return new Secp256r1PublicKey(this.keypair.publicKey);
-    }
-    /**
-     * The Bech32 secret key string for this Secp256r1 keypair
-     */
-    getSecretKey() {
-        return encodeWowPrivateKey(this.keypair.secretKey, this.getKeyScheme());
-    }
-    /**
-     * Return the signature for the provided data.
-     */
-    async sign(data) {
-        const msgHash = sha256(data);
-        const sig = secp256r1.sign(msgHash, this.keypair.secretKey, {
-            lowS: true,
-        });
-        return sig.toCompactRawBytes();
-    }
-    /**
-     * Derive Secp256r1 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/74'/784'/0'/0/0, otherwise the path must
-     * be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.
-     */
-    static deriveKeypair(mnemonics, path) {
-        if (path == null) {
-            path = DEFAULT_SECP256R1_DERIVATION_PATH;
-        }
-        if (!isValidBIP32Path(path)) {
-            throw new Error("Invalid derivation path");
-        }
-        // We use HDKey which is hardcoded to use Secp256k1 but since we only need the 32 bytes for the private key it's okay to use here as well.
-        const privateKey = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path).privateKey;
-        return Secp256r1Keypair.fromSecretKey(privateKey);
-    }
-}
-//# sourceMappingURL=keypair.js.map
+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,30 +1,11 @@
 import { PublicKey } from "../../cryptography/publickey.js";
 import type { PublicKeyInitData } from "../../cryptography/publickey.js";
-/**
- * A Secp256r1 public key
- */
 export declare class Secp256r1PublicKey extends PublicKey {
     static SIZE: number;
     private data;
-    /**
-     * Create a new Secp256r1PublicKey object
-     * @param value secp256r1 public key as buffer or base-64 encoded string
-     */
     constructor(value: PublicKeyInitData);
-    /**
-     * Checks if two Secp256r1 public keys are equal
-     */
     equals(publicKey: Secp256r1PublicKey): 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>;
 }

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

@@ -1,74 +1 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.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 = 33;
-/**
- * A Secp256r1 public key
- */
-export class Secp256r1PublicKey extends PublicKey {
-    static SIZE = SECP256R1_PUBLIC_KEY_SIZE;
-    data;
-    /**
-     * Create a new Secp256r1PublicKey object
-     * @param value secp256r1 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 !== SECP256R1_PUBLIC_KEY_SIZE) {
-            throw new Error(`Invalid public key input. Expected ${SECP256R1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
-        }
-    }
-    /**
-     * Checks if two Secp256r1 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["Secp256r1"];
-    }
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
-    async verify(message, signature) {
-        let bytes;
-        if (typeof signature === "string") {
-            const parsed = parseSerializedSignature(signature);
-            if (parsed.signatureScheme !== "Secp256r1") {
-                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 secp256r1.verify(secp256r1.Signature.fromCompact(bytes), sha256(message), this.toRawBytes());
-    }
-}
-//# sourceMappingURL=publickey.js.map
+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/multisig/index.js

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

package/dist/esm/multisig/publickey.d.ts

@@ -15,24 +15,11 @@ export type MultiSigPublicKeyStruct = ReturnType<typeof bcs.MultiSigPublicKey.pa
 export type MultiSigStruct = ReturnType<typeof bcs.MultiSig.parse>;
 export type CompressedSignature = ReturnType<typeof bcs.CompressedSignature.parse>;
 export type PublicKeyEnum = ReturnType<typeof bcs.PublicKey.parse>;
-/**
- * A MultiSig public key
- */
 export declare class MultiSigPublicKey extends PublicKey {
     private rawBytes;
     private multisigPublicKey;
     private publicKeys;
-    /**
-     * Create a new MultiSigPublicKey object
-     */
-    constructor(
-    /**
-     *  MultiSig public key as buffer or base-64 encoded string
-     */
-    value: string | Uint8Array | MultiSigPublicKeyStruct);
-    /**
-     * 	A static method to create a new MultiSig publickey instance from a set of public keys and their associated weights pairs and threshold.
-     */
+    constructor(value: string | Uint8Array | MultiSigPublicKeyStruct);
     static fromPublicKeys({ threshold, publicKeys, }: {
         threshold: number;
         publicKeys: {
@@ -40,13 +27,7 @@ export declare class MultiSigPublicKey extends PublicKey {
             weight: number;
         }[];
     }): MultiSigPublicKey;
-    /**
-     * Checks if two MultiSig public keys are equal
-     */
     equals(publicKey: MultiSigPublicKey): boolean;
-    /**
-     * Return the byte array representation of the MultiSig public key
-     */
     toRawBytes(): Uint8Array<ArrayBuffer>;
     getPublicKeys(): {
         weight: number;
@@ -54,26 +35,10 @@ export declare class MultiSigPublicKey extends PublicKey {
     }[];
     getThreshold(): any;
     getSigner(...signers: [signer: Signer]): MultiSigSigner;
-    /**
-     * Return the Sui address associated with this MultiSig public key
-     */
     toWAddress(): string;
-    /**
-     * Return the Sui address associated with this MultiSig public key
-     */
     flag(): number;
-    /**
-     * Verifies that the signature is valid for for the provided message
-     */
     verify(message: Uint8Array, multisigSignature: string): Promise<boolean>;
-    /**
-     * Combines multiple partial signatures into a single multisig, ensuring that each public key signs only once
-     * and that all the public keys involved are known and valid, and then serializes multisig into the standard format
-     */
     combinePartialSignatures(signatures: string[]): string;
 }
-/**
- * Parse multisig structure into an array of individual signatures: signature scheme, the actual individual signature, public key and its weight.
- */
 export declare function parsePartialSignatures(multisig: MultiSigStruct): ParsedPartialMultiSigSignature[];
 export {};