wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,159 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var keypair_exports = {};
+__export(keypair_exports, {
+  DEFAULT_SECP256K1_DERIVATION_PATH: () => DEFAULT_SECP256K1_DERIVATION_PATH,
+  Secp256k1Keypair: () => Secp256k1Keypair
+});
+module.exports = __toCommonJS(keypair_exports);
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_utils = require("@noble/hashes/utils");
+var import_bip32 = require("@scure/bip32");
+var import_keypair = require("../../cryptography/keypair.js");
+var import_mnemonics = require("../../cryptography/mnemonics.js");
+var import_publickey = require("./publickey.js");
+const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
+class Secp256k1Keypair extends import_keypair.Keypair {
+  /**
+   * Create a new keypair instance.
+   * Generate random keypair if no {@link Secp256k1Keypair} is provided.
+   *
+   * @param keypair secp256k1 keypair
+   */
+  constructor(keypair) {
+    super();
+    __publicField(this, "keypair");
+    if (keypair) {
+      this.keypair = keypair;
+    } else {
+      const secretKey = import_secp256k1.secp256k1.utils.randomPrivateKey();
+      const publicKey = import_secp256k1.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 = (0, import_keypair.decodeWowPrivateKey)(secretKey);
+      if (decoded.scheme !== "Secp256k1") {
+        throw new Error(
+          `Expected a Secp256k1 keypair, got ${decoded.scheme}`
+        );
+      }
+      return this.fromSecretKey(decoded.secretKey, options);
+    }
+    const publicKey = import_secp256k1.secp256k1.getPublicKey(secretKey, true);
+    if (!options || !options.skipValidation) {
+      const encoder = new TextEncoder();
+      const signData = encoder.encode("sui validation");
+      const msgHash = (0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(signData, { dkLen: 32 }));
+      const signature = import_secp256k1.secp256k1.sign(msgHash, secretKey);
+      if (!import_secp256k1.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 = import_secp256k1.secp256k1.getPublicKey(seed, true);
+    return new Secp256k1Keypair({ publicKey, secretKey: seed });
+  }
+  /**
+   * The public key for this keypair
+   */
+  getPublicKey() {
+    return new import_publickey.Secp256k1PublicKey(this.keypair.publicKey);
+  }
+  /**
+   * The Bech32 secret key string for this Secp256k1 keypair
+   */
+  getSecretKey() {
+    return (0, import_keypair.encodeWowPrivateKey)(this.keypair.secretKey, this.getKeyScheme());
+  }
+  /**
+   * Return the signature for the provided data.
+   */
+  async sign(data) {
+    const msgHash = (0, import_sha256.sha256)(data);
+    const sig = import_secp256k1.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 (!(0, import_mnemonics.isValidBIP32Path)(path)) {
+      throw new Error("Invalid derivation path");
+    }
+    const key = import_bip32.HDKey.fromMasterSeed((0, import_mnemonics.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
+    });
+  }
+}

package/dist/cjs/keypairs/secp256k1/publickey.d.ts

@@ -0,0 +1,30 @@
+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/cjs/keypairs/secp256k1/publickey.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var publickey_exports = {};
+__export(publickey_exports, {
+  Secp256k1PublicKey: () => Secp256k1PublicKey
+});
+module.exports = __toCommonJS(publickey_exports);
+var import_bcs = require("@mysten/bcs");
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_publickey = require("../../cryptography/publickey.js");
+var import_signature_scheme = require("../../cryptography/signature-scheme.js");
+const SECP256K1_PUBLIC_KEY_SIZE = 33;
+class Secp256k1PublicKey extends import_publickey.PublicKey {
+  /**
+   * Create a new Secp256k1PublicKey object
+   * @param value secp256k1 public key as buffer or base-64 encoded string
+   */
+  constructor(value) {
+    super();
+    __publicField(this, "data");
+    if (typeof value === "string") {
+      this.data = (0, import_bcs.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 import_signature_scheme.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 = (0, import_publickey.parseSerializedKeypairSignature)(signature);
+      if (parsed.signatureScheme !== "Secp256k1") {
+        throw new Error("Invalid signature scheme");
+      }
+      if (!(0, import_publickey.bytesEqual)(this.toRawBytes(), parsed.publicKey)) {
+        throw new Error("Signature does not match public key");
+      }
+      bytes = parsed.signature;
+    } else {
+      bytes = signature;
+    }
+    return import_secp256k1.secp256k1.verify(
+      import_secp256k1.secp256k1.Signature.fromCompact(bytes),
+      (0, import_sha256.sha256)(message),
+      this.toRawBytes()
+    );
+  }
+}
+__publicField(Secp256k1PublicKey, "SIZE", SECP256K1_PUBLIC_KEY_SIZE);

package/dist/cjs/keypairs/secp256r1/index.d.ts

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

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

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var secp256r1_exports = {};
+__export(secp256r1_exports, {
+  DEFAULT_SECP256R1_DERIVATION_PATH: () => import_keypair.DEFAULT_SECP256R1_DERIVATION_PATH,
+  Secp256r1Keypair: () => import_keypair.Secp256r1Keypair,
+  Secp256r1PublicKey: () => import_publickey.Secp256r1PublicKey
+});
+module.exports = __toCommonJS(secp256r1_exports);
+var import_keypair = require("./keypair.js");
+var import_publickey = require("./publickey.js");

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

@@ -0,0 +1,73 @@
+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/cjs/keypairs/secp256r1/keypair.js

@@ -0,0 +1,155 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var keypair_exports = {};
+__export(keypair_exports, {
+  DEFAULT_SECP256R1_DERIVATION_PATH: () => DEFAULT_SECP256R1_DERIVATION_PATH,
+  Secp256r1Keypair: () => Secp256r1Keypair
+});
+module.exports = __toCommonJS(keypair_exports);
+var import_p256 = require("@noble/curves/p256");
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_utils = require("@noble/hashes/utils");
+var import_bip32 = require("@scure/bip32");
+var import_keypair = require("../../cryptography/keypair.js");
+var import_mnemonics = require("../../cryptography/mnemonics.js");
+var import_publickey = require("./publickey.js");
+const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
+class Secp256r1Keypair extends import_keypair.Keypair {
+  /**
+   * Create a new keypair instance.
+   * Generate random keypair if no {@link Secp256r1Keypair} is provided.
+   *
+   * @param keypair Secp256r1 keypair
+   */
+  constructor(keypair) {
+    super();
+    __publicField(this, "keypair");
+    if (keypair) {
+      this.keypair = keypair;
+    } else {
+      const secretKey = import_p256.secp256r1.utils.randomPrivateKey();
+      const publicKey = import_p256.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 = (0, import_keypair.decodeWowPrivateKey)(secretKey);
+      if (decoded.scheme !== "Secp256r1") {
+        throw new Error(
+          `Expected a Secp256r1 keypair, got ${decoded.scheme}`
+        );
+      }
+      return this.fromSecretKey(decoded.secretKey, options);
+    }
+    const publicKey = import_p256.secp256r1.getPublicKey(secretKey, true);
+    if (!options || !options.skipValidation) {
+      const encoder = new TextEncoder();
+      const signData = encoder.encode("sui validation");
+      const msgHash = (0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(signData, { dkLen: 32 }));
+      const signature = import_p256.secp256r1.sign(msgHash, secretKey, {
+        lowS: true
+      });
+      if (!import_p256.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 = import_p256.secp256r1.getPublicKey(seed, true);
+    return new Secp256r1Keypair({ publicKey, secretKey: seed });
+  }
+  /**
+   * The public key for this keypair
+   */
+  getPublicKey() {
+    return new import_publickey.Secp256r1PublicKey(this.keypair.publicKey);
+  }
+  /**
+   * The Bech32 secret key string for this Secp256r1 keypair
+   */
+  getSecretKey() {
+    return (0, import_keypair.encodeWowPrivateKey)(this.keypair.secretKey, this.getKeyScheme());
+  }
+  /**
+   * Return the signature for the provided data.
+   */
+  async sign(data) {
+    const msgHash = (0, import_sha256.sha256)(data);
+    const sig = import_p256.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 (!(0, import_mnemonics.isValidBIP32Path)(path)) {
+      throw new Error("Invalid derivation path");
+    }
+    const privateKey = import_bip32.HDKey.fromMasterSeed(
+      (0, import_mnemonics.mnemonicToSeed)(mnemonics)
+    ).derive(path).privateKey;
+    return Secp256r1Keypair.fromSecretKey(privateKey);
+  }
+}

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

@@ -0,0 +1,30 @@
+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/cjs/keypairs/secp256r1/publickey.js

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var publickey_exports = {};
+__export(publickey_exports, {
+  Secp256r1PublicKey: () => Secp256r1PublicKey
+});
+module.exports = __toCommonJS(publickey_exports);
+var import_bcs = require("@mysten/bcs");
+var import_p256 = require("@noble/curves/p256");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_publickey = require("../../cryptography/publickey.js");
+var import_signature_scheme = require("../../cryptography/signature-scheme.js");
+var import_signature = require("../../cryptography/signature.js");
+const SECP256R1_PUBLIC_KEY_SIZE = 33;
+class Secp256r1PublicKey extends import_publickey.PublicKey {
+  /**
+   * Create a new Secp256r1PublicKey object
+   * @param value secp256r1 public key as buffer or base-64 encoded string
+   */
+  constructor(value) {
+    super();
+    __publicField(this, "data");
+    if (typeof value === "string") {
+      this.data = (0, import_bcs.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 import_signature_scheme.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 = (0, import_signature.parseSerializedSignature)(signature);
+      if (parsed.signatureScheme !== "Secp256r1") {
+        throw new Error("Invalid signature scheme");
+      }
+      if (!(0, import_publickey.bytesEqual)(this.toRawBytes(), parsed.publicKey)) {
+        throw new Error("Signature does not match public key");
+      }
+      bytes = parsed.signature;
+    } else {
+      bytes = signature;
+    }
+    return import_p256.secp256r1.verify(
+      import_p256.secp256r1.Signature.fromCompact(bytes),
+      (0, import_sha256.sha256)(message),
+      this.toRawBytes()
+    );
+  }
+}
+__publicField(Secp256r1PublicKey, "SIZE", SECP256R1_PUBLIC_KEY_SIZE);

package/dist/cjs/multisig/index.d.ts

@@ -0,0 +1,2 @@
+export { MultiSigSigner } from "./signer.js";
+export { type MultiSigStruct, MultiSigPublicKey, parsePartialSignatures, } from "./publickey.js";