wowok 1.8.3 → 2.1.9

package/dist/cjs/cryptography/keypair.d.ts

@@ -0,0 +1,73 @@
+import type { IntentScope } from "./intent.js";
+import type { PublicKey } from "./publickey.js";
+import type { SignatureScheme } from "./signature-scheme.js";
+import type { Transaction } from "../transactions/Transaction.js";
+import type { ClientWithCoreApi, Experimental_SuiClientTypes } from "../experimental/index.js";
+export declare const PRIVATE_KEY_SIZE = 32;
+export declare const LEGACY_PRIVATE_KEY_SIZE = 64;
+export declare const W_PRIVATE_KEY_PREFIX = "wowprivkey";
+export type ParsedKeypair = {
+    scheme: SignatureScheme;
+    secretKey: Uint8Array;
+};
+export interface SignatureWithBytes {
+    bytes: string;
+    signature: string;
+}
+export interface SignAndExecuteOptions {
+    transaction: Transaction;
+    client: ClientWithCoreApi;
+}
+/**
+ * TODO: Document
+ */
+export declare abstract class Signer {
+    abstract sign(bytes: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * Sign messages with a specific intent. By combining the message bytes with the intent before hashing and signing,
+     * it ensures that a signed message is tied to a specific purpose and domain separator is provided
+     */
+    signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes>;
+    /**
+     * Signs provided transaction by calling `signWithIntent()` with a `TransactionData` provided as intent scope
+     */
+    signTransaction(bytes: Uint8Array): Promise<SignatureWithBytes>;
+    /**
+     * Signs provided personal message by calling `signWithIntent()` with a `PersonalMessage` provided as intent scope
+     */
+    signPersonalMessage(bytes: Uint8Array): Promise<{
+        bytes: string;
+        signature: string;
+    }>;
+    signAndExecuteTransaction({ transaction, client, }: SignAndExecuteOptions): Promise<Omit<Experimental_SuiClientTypes.TransactionResponse, "balanceChanges">>;
+    /**
+     * Return the Wow address associated with this keypair
+     */ toWowAddress(): string;
+    /**
+     * Return the Wow address associated with this keypair (alias for toWowAddress)
+     */ toWAddress(): string;
+    /**
+     * Get the key scheme of the keypair: Secp256k1 or ED25519
+     */ abstract getKeyScheme(): SignatureScheme;
+    /**
+     * The public key for this keypair
+     */ abstract getPublicKey(): PublicKey;
+}
+export declare abstract class Keypair extends Signer {
+    /**
+     * This returns the Bech32 secret key string for this keypair.
+     */
+    abstract getSecretKey(): string;
+}
+/**
+ * This returns an ParsedKeypair object based by validating the
+ * 33-byte Bech32 encoded string starting with `wprivkey`, and
+ * parse out the signature scheme and the private key in bytes.
+ */
+export declare function decodeWowPrivateKey(value: string): ParsedKeypair;
+/**
+ * This returns a Bech32 encoded string starting with `wowprivkey`,
+ * encoding 33-byte `flag || bytes` for the given the 32-byte private
+ * key and its signature scheme.
+ */
+export declare function encodeWowPrivateKey(bytes: Uint8Array, scheme: SignatureScheme): string;

package/dist/cjs/cryptography/keypair.js

@@ -0,0 +1,125 @@
+"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 keypair_exports = {};
+__export(keypair_exports, {
+  Keypair: () => Keypair,
+  LEGACY_PRIVATE_KEY_SIZE: () => LEGACY_PRIVATE_KEY_SIZE,
+  PRIVATE_KEY_SIZE: () => PRIVATE_KEY_SIZE,
+  Signer: () => Signer,
+  W_PRIVATE_KEY_PREFIX: () => W_PRIVATE_KEY_PREFIX,
+  decodeWowPrivateKey: () => decodeWowPrivateKey,
+  encodeWowPrivateKey: () => encodeWowPrivateKey
+});
+module.exports = __toCommonJS(keypair_exports);
+var import_bcs = require("@mysten/bcs");
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_base = require("@scure/base");
+var import_intent = require("./intent.js");
+var import_signature_scheme = require("./signature-scheme.js");
+var import_signature = require("./signature.js");
+const PRIVATE_KEY_SIZE = 32;
+const LEGACY_PRIVATE_KEY_SIZE = 64;
+const W_PRIVATE_KEY_PREFIX = "wowprivkey";
+class Signer {
+  /**
+   * Sign messages with a specific intent. By combining the message bytes with the intent before hashing and signing,
+   * it ensures that a signed message is tied to a specific purpose and domain separator is provided
+   */
+  async signWithIntent(bytes, intent) {
+    const intentMessage = (0, import_intent.messageWithIntent)(intent, bytes);
+    const digest = (0, import_blake2b.blake2b)(intentMessage, { dkLen: 32 });
+    const signature = (0, import_signature.toSerializedSignature)({
+      signature: await this.sign(digest),
+      signatureScheme: this.getKeyScheme(),
+      publicKey: this.getPublicKey()
+    });
+    return {
+      signature,
+      bytes: (0, import_bcs.toBase64)(bytes)
+    };
+  }
+  /**
+   * Signs provided transaction by calling `signWithIntent()` with a `TransactionData` provided as intent scope
+   */
+  async signTransaction(bytes) {
+    return this.signWithIntent(bytes, "TransactionData");
+  }
+  /**
+   * Signs provided personal message by calling `signWithIntent()` with a `PersonalMessage` provided as intent scope
+   */
+  async signPersonalMessage(bytes) {
+    const { signature } = await this.signWithIntent(
+      import_bcs.bcs.byteVector().serialize(bytes).toBytes(),
+      "PersonalMessage"
+    );
+    return {
+      bytes: (0, import_bcs.toBase64)(bytes),
+      signature
+    };
+  }
+  async signAndExecuteTransaction({
+    transaction,
+    client
+  }) {
+    const bytes = await transaction.build({ client });
+    const { signature } = await this.signTransaction(bytes);
+    const response = await client.core.executeTransaction({
+      transaction: bytes,
+      signatures: [signature]
+    });
+    return response.transaction;
+  }
+  /**
+   * Return the Wow address associated with this keypair
+   */
+  toWowAddress() {
+    return this.getPublicKey().toWAddress();
+  }
+  /**
+   * Return the Wow address associated with this keypair (alias for toWowAddress)
+   */
+  toWAddress() {
+    return this.toWowAddress();
+  }
+}
+class Keypair extends Signer {
+}
+function decodeWowPrivateKey(value) {
+  const { prefix, words } = import_base.bech32.decode(value);
+  if (prefix !== W_PRIVATE_KEY_PREFIX) {
+    throw new Error("invalid private key prefix");
+  }
+  const extendedSecretKey = new Uint8Array(import_base.bech32.fromWords(words));
+  const secretKey = extendedSecretKey.slice(1);
+  const signatureScheme = import_signature_scheme.SIGNATURE_FLAG_TO_SCHEME[extendedSecretKey[0]];
+  return {
+    scheme: signatureScheme,
+    secretKey
+  };
+}
+function encodeWowPrivateKey(bytes, scheme) {
+  if (bytes.length !== PRIVATE_KEY_SIZE) {
+    throw new Error("Invalid bytes length");
+  }
+  const flag = import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG[scheme];
+  const privKeyBytes = new Uint8Array(bytes.length + 1);
+  privKeyBytes.set([flag]);
+  privKeyBytes.set(bytes, 1);
+  return import_base.bech32.encode(W_PRIVATE_KEY_PREFIX, import_base.bech32.toWords(privKeyBytes));
+}

package/dist/cjs/cryptography/mnemonics.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Parse and validate a path that is compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+ *
+ * @param path path string (e.g. `m/44'/784'/0'/0'/0'`).
+ */
+export declare function isValidHardenedPath(path: string): boolean;
+/**
+ * Parse and validate a path that is compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}
+ * for Secp256k1 and m/74'/784'/{account_index}'/{change_index}/{address_index} for Secp256r1.
+ *
+ * Note that the purpose for Secp256k1 is registered as 54, to differentiate from Ed25519 with purpose 44.
+ *
+ * @param path path string (e.g. `m/54'/784'/0'/0/0`).
+ */
+export declare function isValidBIP32Path(path: string): boolean;
+/**
+ * Uses KDF to derive 64 bytes of key data from mnemonic with empty password.
+ *
+ * @param mnemonics 12 words string split by spaces.
+ */
+export declare function mnemonicToSeed(mnemonics: string): Uint8Array;
+/**
+ * Derive the seed in hex format from a 12-word mnemonic string.
+ *
+ * @param mnemonics 12 words string split by spaces.
+ */
+export declare function mnemonicToSeedHex(mnemonics: string): string;

package/dist/cjs/cryptography/mnemonics.js

@@ -0,0 +1,50 @@
+"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 mnemonics_exports = {};
+__export(mnemonics_exports, {
+  isValidBIP32Path: () => isValidBIP32Path,
+  isValidHardenedPath: () => isValidHardenedPath,
+  mnemonicToSeed: () => mnemonicToSeed,
+  mnemonicToSeedHex: () => mnemonicToSeedHex
+});
+module.exports = __toCommonJS(mnemonics_exports);
+var import_bcs = require("@mysten/bcs");
+var import_bip39 = require("@scure/bip39");
+function isValidHardenedPath(path) {
+  if (!new RegExp("^m\\/44'\\/784'\\/[0-9]+'\\/[0-9]+'\\/[0-9]+'+$").test(
+    path
+  )) {
+    return false;
+  }
+  return true;
+}
+function isValidBIP32Path(path) {
+  if (!new RegExp("^m\\/(54|74)'\\/784'\\/[0-9]+'\\/[0-9]+\\/[0-9]+$").test(
+    path
+  )) {
+    return false;
+  }
+  return true;
+}
+function mnemonicToSeed(mnemonics) {
+  return (0, import_bip39.mnemonicToSeedSync)(mnemonics, "");
+}
+function mnemonicToSeedHex(mnemonics) {
+  return (0, import_bcs.toHex)(mnemonicToSeed(mnemonics));
+}

package/dist/cjs/cryptography/publickey.d.ts

@@ -0,0 +1,67 @@
+import type { IntentScope } from "./intent.js";
+/**
+ * Value to be converted into public key.
+ */
+export type PublicKeyInitData = string | Uint8Array | Iterable<number>;
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * A public key
+ */
+export declare abstract class PublicKey {
+    /**
+     * Checks if two public keys are equal
+     */
+    equals(publicKey: PublicKey): boolean;
+    /**
+     * Return the base-64 representation of the public key
+     */
+    toBase64(): string;
+    toString(): never;
+    /**
+     * Return the Sui representation of the public key encoded in
+     * base-64. A Sui public key is formed by the concatenation
+     * of the scheme flag with the raw bytes of the public key
+     */
+    toWPublicKey(): string;
+    verifyWithIntent(bytes: Uint8Array, signature: Uint8Array | string, intent: IntentScope): Promise<boolean>;
+    /**
+     * Verifies that the signature is valid for for the provided PersonalMessage
+     */
+    verifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+    /**
+     * Verifies that the signature is valid for for the provided Transaction
+     */
+    verifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+    /**
+     * Verifies that the public key is associated with the provided address
+     */
+    verifyAddress(address: string): boolean;
+    /**
+     * Returns the bytes representation of the public key
+     * prefixed with the signature scheme flag
+     */
+    toWBytes(): Uint8Array<ArrayBuffer>;
+    /**
+     * Return the Sui address associated with this Ed25519 public key
+     */
+    toWAddress(): string;
+    /**
+     * Return the byte array representation of the public key
+     */
+    abstract toRawBytes(): Uint8Array<ArrayBuffer>;
+    /**
+     * Return signature scheme flag of the public key
+     */
+    abstract flag(): number;
+    /**
+     * Verifies that the signature is valid for for the provided message
+     */
+    abstract verify(data: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+}
+export declare function parseSerializedKeypairSignature(serializedSignature: string): {
+    serializedSignature: string;
+    signatureScheme: "ED25519" | "Secp256k1" | "Secp256r1";
+    signature: Uint8Array<ArrayBuffer>;
+    publicKey: Uint8Array<ArrayBuffer>;
+    bytes: Uint8Array<ArrayBuffer>;
+};

package/dist/cjs/cryptography/publickey.js

@@ -0,0 +1,142 @@
+"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 publickey_exports = {};
+__export(publickey_exports, {
+  PublicKey: () => PublicKey,
+  bytesEqual: () => bytesEqual,
+  parseSerializedKeypairSignature: () => parseSerializedKeypairSignature
+});
+module.exports = __toCommonJS(publickey_exports);
+var import_bcs = require("@mysten/bcs");
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_utils = require("@noble/hashes/utils");
+var import_bcs2 = require("../bcs/index.js");
+var import_sui_types = require("../utils/sui-types.js");
+var import_intent = require("./intent.js");
+var import_signature_scheme = require("./signature-scheme.js");
+function bytesEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+class PublicKey {
+  /**
+   * Checks if two public keys are equal
+   */
+  equals(publicKey) {
+    return bytesEqual(this.toRawBytes(), publicKey.toRawBytes());
+  }
+  /**
+   * Return the base-64 representation of the public key
+   */
+  toBase64() {
+    return (0, import_bcs.toBase64)(this.toRawBytes());
+  }
+  toString() {
+    throw new Error(
+      "`toString` is not implemented on public keys. Use `toBase64()` or `toRawBytes()` instead."
+    );
+  }
+  /**
+   * Return the Sui representation of the public key encoded in
+   * base-64. A Sui public key is formed by the concatenation
+   * of the scheme flag with the raw bytes of the public key
+   */
+  toWPublicKey() {
+    const bytes = this.toWBytes();
+    return (0, import_bcs.toBase64)(bytes);
+  }
+  verifyWithIntent(bytes, signature, intent) {
+    const intentMessage = (0, import_intent.messageWithIntent)(intent, bytes);
+    const digest = (0, import_blake2b.blake2b)(intentMessage, { dkLen: 32 });
+    return this.verify(digest, signature);
+  }
+  /**
+   * Verifies that the signature is valid for for the provided PersonalMessage
+   */
+  verifyPersonalMessage(message, signature) {
+    return this.verifyWithIntent(
+      import_bcs2.bcs.byteVector().serialize(message).toBytes(),
+      signature,
+      "PersonalMessage"
+    );
+  }
+  /**
+   * Verifies that the signature is valid for for the provided Transaction
+   */
+  verifyTransaction(transaction, signature) {
+    return this.verifyWithIntent(transaction, signature, "TransactionData");
+  }
+  /**
+   * Verifies that the public key is associated with the provided address
+   */
+  verifyAddress(address) {
+    return this.toWAddress() === address;
+  }
+  /**
+   * Returns the bytes representation of the public key
+   * prefixed with the signature scheme flag
+   */
+  toWBytes() {
+    const rawBytes = this.toRawBytes();
+    const suiBytes = new Uint8Array(rawBytes.length + 1);
+    suiBytes.set([this.flag()]);
+    suiBytes.set(rawBytes, 1);
+    return suiBytes;
+  }
+  /**
+   * Return the Sui address associated with this Ed25519 public key
+   */
+  toWAddress() {
+    return (0, import_sui_types.normalizeWowAddress)(
+      (0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(this.toWBytes(), { dkLen: 32 })).slice(
+        0,
+        import_sui_types.WOW_ADDRESS_LENGTH * 2
+      )
+    );
+  }
+}
+function parseSerializedKeypairSignature(serializedSignature) {
+  const bytes = (0, import_bcs.fromBase64)(serializedSignature);
+  const signatureScheme = import_signature_scheme.SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+  switch (signatureScheme) {
+    case "ED25519":
+    case "Secp256k1":
+    case "Secp256r1":
+      const size = import_signature_scheme.SIGNATURE_SCHEME_TO_SIZE[signatureScheme];
+      const signature = bytes.slice(1, bytes.length - size);
+      const publicKey = bytes.slice(1 + signature.length);
+      return {
+        serializedSignature,
+        signatureScheme,
+        signature,
+        publicKey,
+        bytes
+      };
+    default:
+      throw new Error("Unsupported signature scheme");
+  }
+}

package/dist/cjs/cryptography/signature-scheme.d.ts

@@ -0,0 +1,24 @@
+export declare const SIGNATURE_SCHEME_TO_FLAG: {
+    readonly ED25519: 0;
+    readonly Secp256k1: 1;
+    readonly Secp256r1: 2;
+    readonly MultiSig: 3;
+    readonly ZkLogin: 5;
+    readonly Passkey: 6;
+};
+export declare const SIGNATURE_SCHEME_TO_SIZE: {
+    ED25519: number;
+    Secp256k1: number;
+    Secp256r1: number;
+    Passkey: number;
+};
+export declare const SIGNATURE_FLAG_TO_SCHEME: {
+    readonly 0: "ED25519";
+    readonly 1: "Secp256k1";
+    readonly 2: "Secp256r1";
+    readonly 3: "MultiSig";
+    readonly 5: "ZkLogin";
+    readonly 6: "Passkey";
+};
+export type SignatureScheme = "ED25519" | "Secp256k1" | "Secp256r1" | "MultiSig" | "ZkLogin" | "Passkey";
+export type SignatureFlag = keyof typeof SIGNATURE_FLAG_TO_SCHEME;

package/dist/cjs/cryptography/signature-scheme.js

@@ -0,0 +1,47 @@
+"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 signature_scheme_exports = {};
+__export(signature_scheme_exports, {
+  SIGNATURE_FLAG_TO_SCHEME: () => SIGNATURE_FLAG_TO_SCHEME,
+  SIGNATURE_SCHEME_TO_FLAG: () => SIGNATURE_SCHEME_TO_FLAG,
+  SIGNATURE_SCHEME_TO_SIZE: () => SIGNATURE_SCHEME_TO_SIZE
+});
+module.exports = __toCommonJS(signature_scheme_exports);
+const SIGNATURE_SCHEME_TO_FLAG = {
+  ED25519: 0,
+  Secp256k1: 1,
+  Secp256r1: 2,
+  MultiSig: 3,
+  ZkLogin: 5,
+  Passkey: 6
+};
+const SIGNATURE_SCHEME_TO_SIZE = {
+  ED25519: 32,
+  Secp256k1: 33,
+  Secp256r1: 33,
+  Passkey: 33
+};
+const SIGNATURE_FLAG_TO_SCHEME = {
+  0: "ED25519",
+  1: "Secp256k1",
+  2: "Secp256r1",
+  3: "MultiSig",
+  5: "ZkLogin",
+  6: "Passkey"
+};

package/dist/cjs/cryptography/signature.d.ts

@@ -0,0 +1,62 @@
+import type { PublicKey } from "./publickey.js";
+import type { SignatureScheme } from "./signature-scheme.js";
+/**
+ * Pair of signature and corresponding public key
+ */
+export type SerializeSignatureInput = {
+    signatureScheme: SignatureScheme;
+    /** Base64-encoded signature */
+    signature: Uint8Array;
+    /** Base64-encoded public key */
+    publicKey?: PublicKey;
+};
+/**
+ * Takes in a signature, its associated signing scheme and a public key, then serializes this data
+ */
+export declare function toSerializedSignature({ signature, signatureScheme, publicKey, }: SerializeSignatureInput): string;
+/**
+ * Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key
+ */
+export declare function parseSerializedSignature(serializedSignature: string): {
+    serializedSignature: string;
+    signatureScheme: "ED25519" | "Secp256k1" | "Secp256r1";
+    signature: Uint8Array<ArrayBuffer>;
+    publicKey: Uint8Array<ArrayBuffer>;
+    bytes: Uint8Array<ArrayBuffer>;
+} | {
+    signatureScheme: "Passkey";
+    serializedSignature: string;
+    signature: Uint8Array<ArrayBufferLike>;
+    authenticatorData: Uint8Array<ArrayBufferLike>;
+    clientDataJson: string;
+    userSignature: Uint8Array<ArrayBuffer>;
+    publicKey: Uint8Array<ArrayBuffer>;
+} | {
+    serializedSignature: string;
+    signatureScheme: "MultiSig";
+    multisig: {
+        sigs: import("@mysten/bcs").EnumOutputShapeWithKeys<{
+            ED25519: Uint8Array<ArrayBufferLike>;
+            Secp256k1: Uint8Array<ArrayBufferLike>;
+            Secp256r1: Uint8Array<ArrayBufferLike>;
+            ZkLogin: Uint8Array<ArrayBufferLike>;
+            Passkey: Uint8Array<ArrayBufferLike>;
+        }, "ED25519" | "Secp256k1" | "Secp256r1" | "ZkLogin" | "Passkey">[];
+        bitmap: number;
+        multisig_pk: {
+            pk_map: {
+                pubKey: import("@mysten/bcs").EnumOutputShapeWithKeys<{
+                    ED25519: Uint8Array<ArrayBufferLike>;
+                    Secp256k1: Uint8Array<ArrayBufferLike>;
+                    Secp256r1: Uint8Array<ArrayBufferLike>;
+                    ZkLogin: Uint8Array<ArrayBufferLike>;
+                    Passkey: Uint8Array<ArrayBufferLike>;
+                }, "ED25519" | "Secp256k1" | "Secp256r1" | "ZkLogin" | "Passkey">;
+                weight: number;
+            }[];
+            threshold: number;
+        };
+    };
+    bytes: Uint8Array<ArrayBuffer>;
+    signature: undefined;
+};