wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,82 @@
+"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 ed25519_hd_key_exports = {};
+__export(ed25519_hd_key_exports, {
+  derivePath: () => derivePath
+});
+module.exports = __toCommonJS(ed25519_hd_key_exports);
+var import_bcs = require("@mysten/bcs");
+var import_hmac = require("@noble/hashes/hmac");
+var import_sha512 = require("@noble/hashes/sha512");
+const ED25519_CURVE = "ed25519 seed";
+const HARDENED_OFFSET = 2147483648;
+const pathRegex = new RegExp("^m(\\/[0-9]+')+$");
+const replaceDerive = (val) => val.replace("'", "");
+const getMasterKeyFromSeed = (seed) => {
+  const h = import_hmac.hmac.create(import_sha512.sha512, ED25519_CURVE);
+  const I = h.update((0, import_bcs.fromHex)(seed)).digest();
+  const IL = I.slice(0, 32);
+  const IR = I.slice(32);
+  return {
+    key: IL,
+    chainCode: IR
+  };
+};
+const CKDPriv = ({ key, chainCode }, index) => {
+  const indexBuffer = new ArrayBuffer(4);
+  const cv = new DataView(indexBuffer);
+  cv.setUint32(0, index);
+  const data = new Uint8Array(1 + key.length + indexBuffer.byteLength);
+  data.set(new Uint8Array(1).fill(0));
+  data.set(key, 1);
+  data.set(
+    new Uint8Array(indexBuffer, 0, indexBuffer.byteLength),
+    key.length + 1
+  );
+  const I = import_hmac.hmac.create(import_sha512.sha512, chainCode).update(data).digest();
+  const IL = I.slice(0, 32);
+  const IR = I.slice(32);
+  return {
+    key: IL,
+    chainCode: IR
+  };
+};
+const isValidPath = (path) => {
+  if (!pathRegex.test(path)) {
+    return false;
+  }
+  return !path.split("/").slice(1).map(replaceDerive).some(
+    isNaN
+    /* ts T_T*/
+  );
+};
+const derivePath = (path, seed, offset = HARDENED_OFFSET) => {
+  if (!isValidPath(path)) {
+    throw new Error("Invalid derivation path");
+  }
+  const { key, chainCode } = getMasterKeyFromSeed(seed);
+  const segments = path.split("/").slice(1).map(replaceDerive).map((el) => parseInt(el, 10));
+  return segments.reduce(
+    (parentKeys, segment) => CKDPriv(parentKeys, segment + offset),
+    {
+      key,
+      chainCode
+    }
+  );
+};

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

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

package/dist/cjs/keypairs/ed25519/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 ed25519_exports = {};
+__export(ed25519_exports, {
+  DEFAULT_ED25519_DERIVATION_PATH: () => import_keypair.DEFAULT_ED25519_DERIVATION_PATH,
+  Ed25519Keypair: () => import_keypair.Ed25519Keypair,
+  Ed25519PublicKey: () => import_publickey.Ed25519PublicKey
+});
+module.exports = __toCommonJS(ed25519_exports);
+var import_keypair = require("./keypair.js");
+var import_publickey = require("./publickey.js");

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

@@ -0,0 +1,74 @@
+import { Keypair } from "../../cryptography/keypair.js";
+import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
+import { Ed25519PublicKey } from "./publickey.js";
+export declare const DEFAULT_ED25519_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
+/**
+ * Ed25519 Keypair data. The publickey is the 32-byte public key and
+ * the secretkey is 64-byte, where the first 32 bytes is the secret
+ * key and the last 32 bytes is the public key.
+ */
+export interface Ed25519KeypairData {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+/**
+ * An Ed25519 Keypair used for signing transactions.
+ */
+export declare class Ed25519Keypair extends Keypair {
+    private keypair;
+    /**
+     * Create a new Ed25519 keypair instance.
+     * Generate random keypair if no {@link Ed25519Keypair} is provided.
+     *
+     * @param keypair Ed25519 keypair
+     */
+    constructor(keypair?: Ed25519KeypairData);
+    /**
+     * Get the key scheme of the keypair ED25519
+     */
+    getKeyScheme(): SignatureScheme;
+    /**
+     * Generate a new random Ed25519 keypair
+     */
+    static generate(): Ed25519Keypair;
+    /**
+     * Create a Ed25519 keypair from a raw secret key byte array, also known as seed.
+     * This is NOT the private scalar which is result of hashing and bit clamping of
+     * the raw secret key.
+     *
+     * @throws error if the provided secret key is invalid and validation is not skipped.
+     *
+     * @param secretKey secret key as a byte array or Bech32 secret key string
+     * @param options: skip secret key validation
+     */
+    static fromSecretKey(secretKey: Uint8Array | string, options?: {
+        skipValidation?: boolean;
+    }): Ed25519Keypair;
+    /**
+     * The public key for this Ed25519 keypair
+     */
+    getPublicKey(): Ed25519PublicKey;
+    /**
+     * The Bech32 secret key string for this Ed25519 keypair
+     */
+    getSecretKey(): string;
+    /**
+     * Return the signature for the provided data using Ed25519.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * Derive Ed25519 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/44'/784'/0'/0'/0', otherwise the path must
+     * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+     */
+    static deriveKeypair(mnemonics: string, path?: string): Ed25519Keypair;
+    /**
+     * Derive Ed25519 keypair from mnemonicSeed and path.
+     *
+     * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+     * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+     */
+    static deriveKeypairFromSeed(seedHex: string, path?: string): Ed25519Keypair;
+}

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

@@ -0,0 +1,169 @@
+"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_ED25519_DERIVATION_PATH: () => DEFAULT_ED25519_DERIVATION_PATH,
+  Ed25519Keypair: () => Ed25519Keypair
+});
+module.exports = __toCommonJS(keypair_exports);
+var import_ed25519 = require("@noble/curves/ed25519");
+var import_keypair = require("../../cryptography/keypair.js");
+var import_mnemonics = require("../../cryptography/mnemonics.js");
+var import_ed25519_hd_key = require("./ed25519-hd-key.js");
+var import_publickey = require("./publickey.js");
+const DEFAULT_ED25519_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
+class Ed25519Keypair extends import_keypair.Keypair {
+  /**
+   * Create a new Ed25519 keypair instance.
+   * Generate random keypair if no {@link Ed25519Keypair} is provided.
+   *
+   * @param keypair Ed25519 keypair
+   */
+  constructor(keypair) {
+    super();
+    __publicField(this, "keypair");
+    if (keypair) {
+      this.keypair = {
+        publicKey: keypair.publicKey,
+        secretKey: keypair.secretKey.slice(0, 32)
+      };
+    } else {
+      const privateKey = import_ed25519.ed25519.utils.randomPrivateKey();
+      this.keypair = {
+        publicKey: import_ed25519.ed25519.getPublicKey(privateKey),
+        secretKey: privateKey
+      };
+    }
+  }
+  /**
+   * Get the key scheme of the keypair ED25519
+   */
+  getKeyScheme() {
+    return "ED25519";
+  }
+  /**
+   * Generate a new random Ed25519 keypair
+   */
+  static generate() {
+    const secretKey = import_ed25519.ed25519.utils.randomPrivateKey();
+    return new Ed25519Keypair({
+      publicKey: import_ed25519.ed25519.getPublicKey(secretKey),
+      secretKey
+    });
+  }
+  /**
+   * Create a Ed25519 keypair from a raw secret key byte array, also known as seed.
+   * This is NOT the private scalar which is result of hashing and bit clamping of
+   * the raw secret key.
+   *
+   * @throws error if the provided secret key is invalid and validation is not skipped.
+   *
+   * @param secretKey secret key as a 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 !== "ED25519") {
+        throw new Error(
+          `Expected a ED25519 keypair, got ${decoded.scheme}`
+        );
+      }
+      return this.fromSecretKey(decoded.secretKey, options);
+    }
+    const secretKeyLength = secretKey.length;
+    if (secretKeyLength !== import_keypair.PRIVATE_KEY_SIZE) {
+      throw new Error(
+        `Wrong secretKey size. Expected ${import_keypair.PRIVATE_KEY_SIZE} bytes, got ${secretKeyLength}.`
+      );
+    }
+    const keypair = {
+      publicKey: import_ed25519.ed25519.getPublicKey(secretKey),
+      secretKey
+    };
+    if (!options || !options.skipValidation) {
+      const encoder = new TextEncoder();
+      const signData = encoder.encode("sui validation");
+      const signature = import_ed25519.ed25519.sign(signData, secretKey);
+      if (!import_ed25519.ed25519.verify(signature, signData, keypair.publicKey)) {
+        throw new Error("provided secretKey is invalid");
+      }
+    }
+    return new Ed25519Keypair(keypair);
+  }
+  /**
+   * The public key for this Ed25519 keypair
+   */
+  getPublicKey() {
+    return new import_publickey.Ed25519PublicKey(this.keypair.publicKey);
+  }
+  /**
+   * The Bech32 secret key string for this Ed25519 keypair
+   */
+  getSecretKey() {
+    return (0, import_keypair.encodeWowPrivateKey)(
+      this.keypair.secretKey.slice(0, import_keypair.PRIVATE_KEY_SIZE),
+      this.getKeyScheme()
+    );
+  }
+  /**
+   * Return the signature for the provided data using Ed25519.
+   */
+  async sign(data) {
+    return import_ed25519.ed25519.sign(
+      data,
+      this.keypair.secretKey
+    );
+  }
+  /**
+   * Derive Ed25519 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/44'/784'/0'/0'/0', otherwise the path must
+   * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+   */
+  static deriveKeypair(mnemonics, path) {
+    if (path == null) {
+      path = DEFAULT_ED25519_DERIVATION_PATH;
+    }
+    if (!(0, import_mnemonics.isValidHardenedPath)(path)) {
+      throw new Error("Invalid derivation path");
+    }
+    const { key } = (0, import_ed25519_hd_key.derivePath)(path, (0, import_mnemonics.mnemonicToSeedHex)(mnemonics));
+    return Ed25519Keypair.fromSecretKey(key);
+  }
+  /**
+   * Derive Ed25519 keypair from mnemonicSeed and path.
+   *
+   * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+   * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+   */
+  static deriveKeypairFromSeed(seedHex, path) {
+    if (path == null) {
+      path = DEFAULT_ED25519_DERIVATION_PATH;
+    }
+    if (!(0, import_mnemonics.isValidHardenedPath)(path)) {
+      throw new Error("Invalid derivation path");
+    }
+    const { key } = (0, import_ed25519_hd_key.derivePath)(path, seedHex);
+    return Ed25519Keypair.fromSecretKey(key);
+  }
+}

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

@@ -0,0 +1,30 @@
+import { PublicKey } from "../../cryptography/publickey.js";
+import type { PublicKeyInitData } from "../../cryptography/publickey.js";
+/**
+ * An Ed25519 public key
+ */
+export declare class Ed25519PublicKey extends PublicKey {
+    static SIZE: number;
+    private data;
+    /**
+     * Create a new Ed25519PublicKey object
+     * @param value ed25519 public key as buffer or base-64 encoded string
+     */
+    constructor(value: PublicKeyInitData);
+    /**
+     * Checks if two Ed25519 public keys are equal
+     */
+    equals(publicKey: Ed25519PublicKey): boolean;
+    /**
+     * Return the byte array representation of the Ed25519 public key
+     */
+    toRawBytes(): Uint8Array<ArrayBuffer>;
+    /**
+     * Return the Sui address associated with this Ed25519 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/ed25519/publickey.js

@@ -0,0 +1,90 @@
+"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, {
+  Ed25519PublicKey: () => Ed25519PublicKey
+});
+module.exports = __toCommonJS(publickey_exports);
+var import_bcs = require("@mysten/bcs");
+var import_ed25519 = require("@noble/curves/ed25519");
+var import_publickey = require("../../cryptography/publickey.js");
+var import_signature_scheme = require("../../cryptography/signature-scheme.js");
+const PUBLIC_KEY_SIZE = 32;
+class Ed25519PublicKey extends import_publickey.PublicKey {
+  /**
+   * Create a new Ed25519PublicKey object
+   * @param value ed25519 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 !== PUBLIC_KEY_SIZE) {
+      throw new Error(
+        `Invalid public key input. Expected ${PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`
+      );
+    }
+  }
+  /**
+   * Checks if two Ed25519 public keys are equal
+   */
+  equals(publicKey) {
+    return super.equals(publicKey);
+  }
+  /**
+   * Return the byte array representation of the Ed25519 public key
+   */
+  toRawBytes() {
+    return this.data;
+  }
+  /**
+   * Return the Sui address associated with this Ed25519 public key
+   */
+  flag() {
+    return import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG["ED25519"];
+  }
+  /**
+   * 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 !== "ED25519") {
+        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_ed25519.ed25519.verify(bytes, message, this.toRawBytes());
+  }
+}
+__publicField(Ed25519PublicKey, "SIZE", PUBLIC_KEY_SIZE);

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

@@ -0,0 +1,4 @@
+export * from "./ed25519/index.js";
+export * from "./passkey/index.js";
+export * from "./secp256k1/index.js";
+export * from "./secp256r1/index.js";

package/dist/cjs/keypairs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var keypairs_exports = {};
+module.exports = __toCommonJS(keypairs_exports);
+__reExport(keypairs_exports, require("./ed25519/index.js"), module.exports);
+__reExport(keypairs_exports, require("./passkey/index.js"), module.exports);
+__reExport(keypairs_exports, require("./secp256k1/index.js"), module.exports);
+__reExport(keypairs_exports, require("./secp256r1/index.js"), module.exports);

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

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

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

@@ -0,0 +1,28 @@
+"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 passkey_exports = {};
+__export(passkey_exports, {
+  BrowserPasskeyProvider: () => import_keypair.BrowserPasskeyProvider,
+  PasskeyKeypair: () => import_keypair.PasskeyKeypair,
+  PasskeyPublicKey: () => import_publickey.PasskeyPublicKey,
+  findCommonPublicKey: () => import_keypair.findCommonPublicKey
+});
+module.exports = __toCommonJS(passkey_exports);
+var import_keypair = require("./keypair.js");
+var import_publickey = require("./publickey.js");

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

@@ -0,0 +1,113 @@
+import type { IntentScope, SignatureWithBytes } from "../../cryptography/index.js";
+import { Signer } from "../../cryptography/index.js";
+import type { PublicKey } from "../../cryptography/publickey.js";
+import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
+import type { AuthenticationCredential, RegistrationCredential } from "./types.js";
+type DeepPartialConfigKeys = "rp" | "user" | "authenticatorSelection";
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type BrowserPasswordProviderOptions = Pick<DeepPartial<PublicKeyCredentialCreationOptions>, DeepPartialConfigKeys> & Omit<Partial<PublicKeyCredentialCreationOptions>, DeepPartialConfigKeys | "pubKeyCredParams" | "challenge">;
+export interface PasskeyProvider {
+    create(): Promise<RegistrationCredential>;
+    get(challenge: Uint8Array): Promise<AuthenticationCredential>;
+}
+export declare class BrowserPasskeyProvider implements PasskeyProvider {
+    #private;
+    constructor(name: string, options: BrowserPasswordProviderOptions);
+    create(): Promise<RegistrationCredential>;
+    get(challenge: Uint8Array): Promise<AuthenticationCredential>;
+}
+/**
+ * @experimental
+ * A passkey signer used for signing transactions. This is a client side implementation for [SIP-9](https://github.com/sui-foundation/sips/blob/main/sips/sip-9.md).
+ */
+export declare class PasskeyKeypair extends Signer {
+    private publicKey;
+    private provider;
+    /**
+     * Get the key scheme of passkey,
+     */
+    getKeyScheme(): SignatureScheme;
+    /**
+     * Creates an instance of Passkey signer. If no passkey wallet had created before,
+     * use `getPasskeyInstance`. For example:
+     * ```
+     * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
+     * 	  rpName: 'Sui Passkey Example',
+     * 	  rpId: window.location.hostname,
+     * } as BrowserPasswordProviderOptions);
+     * const signer = await PasskeyKeypair.getPasskeyInstance(provider);
+     * ```
+     *
+     * If there are existing passkey wallet, use `signAndRecover` to identify the correct
+     * public key and then initialize the instance. See usage in `signAndRecover`.
+     */
+    constructor(publicKey: Uint8Array, provider: PasskeyProvider);
+    /**
+     * Creates an instance of Passkey signer invoking the passkey from navigator.
+     * Note that this will invoke the passkey device to create a fresh credential.
+     * Should only be called if passkey wallet is created for the first time.
+     *
+     * @param provider - the passkey provider.
+     * @returns the passkey instance.
+     */
+    static getPasskeyInstance(provider: PasskeyProvider): Promise<PasskeyKeypair>;
+    /**
+     * Return the public key for this passkey.
+     */
+    getPublicKey(): PublicKey;
+    /**
+     * Return the signature for the provided data (i.e. blake2b(intent_message)).
+     * This is sent to passkey as the challenge field.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * This overrides the base class implementation that accepts the raw bytes and signs its
+     * digest of the intent message, then serialize it with the passkey flag.
+     */
+    signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes>;
+    /**
+     * Given a message, asks the passkey device to sign it and return all (up to 4) possible public keys.
+     * See: https://bitcoin.stackexchange.com/questions/81232/how-is-public-key-extracted-from-message-digital-signature-address
+     *
+     * This is useful if the user previously created passkey wallet with the origin, but the wallet session
+     * does not have the public key / address. By calling this method twice with two different messages, the
+     * wallet can compare the returned public keys and uniquely identify the previously created passkey wallet
+     * using `findCommonPublicKey`.
+     *
+     * Alternatively, one call can be made and all possible public keys should be checked onchain to see if
+     * there is any assets.
+     *
+     * Once the correct public key is identified, a passkey instance can then be initialized with this public key.
+     *
+     * Example usage to recover wallet with two signing calls:
+     * ```
+     * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
+     *     rpName: 'Sui Passkey Example',
+     * 	   rpId: window.location.hostname,
+     * } as BrowserPasswordProviderOptions);
+     * const testMessage = new TextEncoder().encode('Hello world!');
+     * const possiblePks = await PasskeyKeypair.signAndRecover(provider, testMessage);
+     * const testMessage2 = new TextEncoder().encode('Hello world 2!');
+     * const possiblePks2 = await PasskeyKeypair.signAndRecover(provider, testMessage2);
+     * const commonPk = findCommonPublicKey(possiblePks, possiblePks2);
+     * const signer = new PasskeyKeypair(provider, commonPk.toRawBytes());
+     * ```
+     *
+     * @param provider - the passkey provider.
+     * @param message - the message to sign.
+     * @returns all possible public keys.
+     */
+    static signAndRecover(provider: PasskeyProvider, message: Uint8Array): Promise<PublicKey[]>;
+}
+/**
+ * Finds the unique public key that exists in both arrays, throws error if the common
+ * pubkey does not equal to one.
+ *
+ * @param arr1 - The first pubkeys array.
+ * @param arr2 - The second pubkeys array.
+ * @returns The only common pubkey in both arrays.
+ */
+export declare function findCommonPublicKey(arr1: PublicKey[], arr2: PublicKey[]): PublicKey;
+export {};