wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,147 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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";
+const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
+class Secp256k1Keypair extends 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 = 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
+    });
+  }
+}
+export {
+  DEFAULT_SECP256K1_DERIVATION_PATH,
+  Secp256k1Keypair
+};

package/dist/esm/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/esm/keypairs/secp256k1/publickey.js

@@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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;
+class Secp256k1PublicKey extends 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 = 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()
+    );
+  }
+}
+__publicField(Secp256k1PublicKey, "SIZE", SECP256K1_PUBLIC_KEY_SIZE);
+export {
+  Secp256k1PublicKey
+};

package/dist/esm/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/esm/keypairs/secp256r1/index.js

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

package/dist/esm/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/esm/keypairs/secp256r1/keypair.js

@@ -0,0 +1,143 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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";
+const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
+class Secp256r1Keypair extends 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 = 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");
+    }
+    const privateKey = HDKey.fromMasterSeed(
+      mnemonicToSeed(mnemonics)
+    ).derive(path).privateKey;
+    return Secp256r1Keypair.fromSecretKey(privateKey);
+  }
+}
+export {
+  DEFAULT_SECP256R1_DERIVATION_PATH,
+  Secp256r1Keypair
+};

package/dist/esm/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/esm/keypairs/secp256r1/publickey.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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;
+class Secp256r1PublicKey extends 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 = 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()
+    );
+  }
+}
+__publicField(Secp256r1PublicKey, "SIZE", SECP256R1_PUBLIC_KEY_SIZE);
+export {
+  Secp256r1PublicKey
+};

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

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

package/dist/esm/multisig/index.js

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

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

@@ -0,0 +1,79 @@
+import { bcs } from "../bcs/index.js";
+import type { Signer } from "../cryptography/keypair.js";
+import { PublicKey } from "../cryptography/publickey.js";
+import type { SignatureScheme } from "../cryptography/signature-scheme.js";
+import { MultiSigSigner } from "./signer.js";
+type ParsedPartialMultiSigSignature = {
+    signatureScheme: SignatureScheme;
+    signature: Uint8Array;
+    publicKey: PublicKey;
+    weight: number;
+};
+export declare const MAX_SIGNER_IN_MULTISIG = 10;
+export declare const MIN_SIGNER_IN_MULTISIG = 1;
+export type MultiSigPublicKeyStruct = ReturnType<typeof bcs.MultiSigPublicKey.parse>;
+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.
+     */
+    static fromPublicKeys({ threshold, publicKeys, }: {
+        threshold: number;
+        publicKeys: {
+            publicKey: 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;
+        publicKey: PublicKey;
+    }[];
+    getThreshold(): number;
+    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 {};