wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,268 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var keypair_exports = {};
+__export(keypair_exports, {
+  BrowserPasskeyProvider: () => BrowserPasskeyProvider,
+  PasskeyKeypair: () => PasskeyKeypair,
+  findCommonPublicKey: () => findCommonPublicKey
+});
+module.exports = __toCommonJS(keypair_exports);
+var import_bcs = require("@mysten/bcs");
+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_bcs2 = require("../../bcs/bcs.js");
+var import_cryptography = require("../../cryptography/index.js");
+var import_publickey = require("./publickey.js");
+var _name, _options;
+class BrowserPasskeyProvider {
+  constructor(name, options) {
+    __privateAdd(this, _name);
+    __privateAdd(this, _options);
+    __privateSet(this, _name, name);
+    __privateSet(this, _options, options);
+  }
+  async create() {
+    return await navigator.credentials.create({
+      publicKey: {
+        timeout: __privateGet(this, _options).timeout ?? 6e4,
+        ...__privateGet(this, _options),
+        rp: {
+          name: __privateGet(this, _name),
+          ...__privateGet(this, _options).rp
+        },
+        user: {
+          name: __privateGet(this, _name),
+          displayName: __privateGet(this, _name),
+          ...__privateGet(this, _options).user,
+          id: (0, import_utils.randomBytes)(10)
+        },
+        challenge: new TextEncoder().encode(
+          "Create passkey wallet on Sui"
+        ),
+        pubKeyCredParams: [{ alg: -7, type: "public-key" }],
+        authenticatorSelection: {
+          authenticatorAttachment: "cross-platform",
+          residentKey: "required",
+          requireResidentKey: true,
+          userVerification: "required",
+          ...__privateGet(this, _options).authenticatorSelection
+        }
+      }
+    });
+  }
+  async get(challenge) {
+    return await navigator.credentials.get({
+      publicKey: {
+        challenge,
+        userVerification: __privateGet(this, _options).authenticatorSelection?.userVerification || "required",
+        timeout: __privateGet(this, _options).timeout ?? 6e4
+      }
+    });
+  }
+}
+_name = new WeakMap();
+_options = new WeakMap();
+class PasskeyKeypair extends import_cryptography.Signer {
+  /**
+   * 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, provider) {
+    super();
+    __publicField(this, "publicKey");
+    __publicField(this, "provider");
+    this.publicKey = publicKey;
+    this.provider = provider;
+  }
+  /**
+   * Get the key scheme of passkey,
+   */
+  getKeyScheme() {
+    return "Passkey";
+  }
+  /**
+   * 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 async getPasskeyInstance(provider) {
+    const credential = await provider.create();
+    if (!credential.response.getPublicKey()) {
+      throw new Error("Invalid credential create response");
+    } else {
+      const derSPKI = credential.response.getPublicKey();
+      const pubkeyUncompressed = (0, import_publickey.parseDerSPKI)(new Uint8Array(derSPKI));
+      const pubkey = import_p256.secp256r1.ProjectivePoint.fromHex(pubkeyUncompressed);
+      const pubkeyCompressed = pubkey.toRawBytes(true);
+      return new PasskeyKeypair(pubkeyCompressed, provider);
+    }
+  }
+  /**
+   * Return the public key for this passkey.
+   */
+  getPublicKey() {
+    return new import_publickey.PasskeyPublicKey(this.publicKey);
+  }
+  /**
+   * Return the signature for the provided data (i.e. blake2b(intent_message)).
+   * This is sent to passkey as the challenge field.
+   */
+  async sign(data) {
+    const credential = await this.provider.get(data);
+    const authenticatorData = new Uint8Array(
+      credential.response.authenticatorData
+    );
+    const clientDataJSON = new Uint8Array(
+      credential.response.clientDataJSON
+    );
+    const decoder = new TextDecoder();
+    const clientDataJSONString = decoder.decode(clientDataJSON);
+    const sig = import_p256.secp256r1.Signature.fromDER(
+      new Uint8Array(credential.response.signature)
+    );
+    const normalized = sig.normalizeS().toCompactRawBytes();
+    if (normalized.length !== import_publickey.PASSKEY_SIGNATURE_SIZE || this.publicKey.length !== import_publickey.PASSKEY_PUBLIC_KEY_SIZE) {
+      throw new Error("Invalid signature or public key length");
+    }
+    const arr = new Uint8Array(
+      1 + normalized.length + this.publicKey.length
+    );
+    arr.set([import_cryptography.SIGNATURE_SCHEME_TO_FLAG["Secp256r1"]]);
+    arr.set(normalized, 1);
+    arr.set(this.publicKey, 1 + normalized.length);
+    return import_bcs2.PasskeyAuthenticator.serialize({
+      authenticatorData,
+      clientDataJson: clientDataJSONString,
+      userSignature: arr
+    }).toBytes();
+  }
+  /**
+   * 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.
+   */
+  async signWithIntent(bytes, intent) {
+    const intentMessage = (0, import_cryptography.messageWithIntent)(intent, bytes);
+    const digest = (0, import_blake2b.blake2b)(intentMessage, { dkLen: 32 });
+    const signature = await this.sign(digest);
+    const serializedSignature = new Uint8Array(1 + signature.length);
+    serializedSignature.set([
+      import_cryptography.SIGNATURE_SCHEME_TO_FLAG[this.getKeyScheme()]
+    ]);
+    serializedSignature.set(signature, 1);
+    return {
+      signature: (0, import_bcs.toBase64)(serializedSignature),
+      bytes: (0, import_bcs.toBase64)(bytes)
+    };
+  }
+  /**
+   * 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 async signAndRecover(provider, message) {
+    const credential = await provider.get(message);
+    const fullMessage = messageFromAssertionResponse(credential.response);
+    const sig = import_p256.secp256r1.Signature.fromDER(
+      new Uint8Array(credential.response.signature)
+    );
+    const res = [];
+    for (let i = 0; i < 4; i++) {
+      const s = sig.addRecoveryBit(i);
+      try {
+        const pubkey = s.recoverPublicKey((0, import_sha256.sha256)(fullMessage));
+        const pk = new import_publickey.PasskeyPublicKey(pubkey.toRawBytes(true));
+        res.push(pk);
+      } catch {
+        continue;
+      }
+    }
+    return res;
+  }
+}
+function findCommonPublicKey(arr1, arr2) {
+  const matchingPubkeys = [];
+  for (const pubkey1 of arr1) {
+    for (const pubkey2 of arr2) {
+      if (pubkey1.equals(pubkey2)) {
+        matchingPubkeys.push(pubkey1);
+      }
+    }
+  }
+  if (matchingPubkeys.length !== 1) {
+    throw new Error("No unique public key found");
+  }
+  return matchingPubkeys[0];
+}
+function messageFromAssertionResponse(response) {
+  const authenticatorData = new Uint8Array(response.authenticatorData);
+  const clientDataJSON = new Uint8Array(response.clientDataJSON);
+  const clientDataJSONDigest = (0, import_sha256.sha256)(clientDataJSON);
+  return new Uint8Array([...authenticatorData, ...clientDataJSONDigest]);
+}

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

@@ -0,0 +1,72 @@
+import { PublicKey } from "../../cryptography/publickey.js";
+import type { PublicKeyInitData } from "../../cryptography/publickey.js";
+export declare const PASSKEY_PUBLIC_KEY_SIZE = 33;
+export declare const PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;
+export declare const PASSKEY_SIGNATURE_SIZE = 64;
+/** Fixed DER header for secp256r1 SubjectPublicKeyInfo
+DER structure for P-256 SPKI:
+30 -- SEQUENCE
+  59 -- length (89 bytes)
+  30 -- SEQUENCE
+    13 -- length (19 bytes)
+    06 -- OBJECT IDENTIFIER
+      07 -- length
+      2A 86 48 CE 3D 02 01 -- id-ecPublicKey
+    06 -- OBJECT IDENTIFIER
+      08 -- length
+      2A 86 48 CE 3D 03 01 07 -- secp256r1/prime256v1
+  03 -- BIT STRING
+    42 -- length (66 bytes)
+    00 -- padding
+    ===== above bytes are considered header =====
+    04 || x || y -- uncompressed point (65 bytes: 0x04 || 32-byte x || 32-byte y)
+*/
+export declare const SECP256R1_SPKI_HEADER: Uint8Array<ArrayBuffer>;
+/**
+ * A passkey public key
+ */
+export declare class PasskeyPublicKey extends PublicKey {
+    static SIZE: number;
+    private data;
+    /**
+     * Create a new PasskeyPublicKey object
+     * @param value passkey public key as buffer or base-64 encoded string
+     */
+    constructor(value: PublicKeyInitData);
+    /**
+     * Checks if two passkey public keys are equal
+     */
+    equals(publicKey: PasskeyPublicKey): 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>;
+}
+/**
+ * Parses a DER SubjectPublicKeyInfo into an uncompressed public key. This also verifies
+ * that the curve used is P-256 (secp256r1).
+ *
+ * @param data: DER SubjectPublicKeyInfo
+ * @returns uncompressed public key (`0x04 || x || y`)
+ */
+export declare function parseDerSPKI(derBytes: Uint8Array): Uint8Array;
+/**
+ * Parse signature from bytes or base64 string into the following fields.
+ */
+export declare function parseSerializedPasskeySignature(signature: Uint8Array | string): {
+    signatureScheme: "Passkey";
+    serializedSignature: string;
+    signature: Uint8Array<ArrayBufferLike>;
+    authenticatorData: Uint8Array<ArrayBufferLike>;
+    clientDataJson: string;
+    userSignature: Uint8Array<ArrayBuffer>;
+    publicKey: Uint8Array<ArrayBuffer>;
+};

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

@@ -0,0 +1,175 @@
+"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, {
+  PASSKEY_PUBLIC_KEY_SIZE: () => PASSKEY_PUBLIC_KEY_SIZE,
+  PASSKEY_SIGNATURE_SIZE: () => PASSKEY_SIGNATURE_SIZE,
+  PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE: () => PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE,
+  PasskeyPublicKey: () => PasskeyPublicKey,
+  SECP256R1_SPKI_HEADER: () => SECP256R1_SPKI_HEADER,
+  parseDerSPKI: () => parseDerSPKI,
+  parseSerializedPasskeySignature: () => parseSerializedPasskeySignature
+});
+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_bcs2 = require("../../bcs/bcs.js");
+var import_publickey = require("../../cryptography/publickey.js");
+var import_signature_scheme = require("../../cryptography/signature-scheme.js");
+const PASSKEY_PUBLIC_KEY_SIZE = 33;
+const PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;
+const PASSKEY_SIGNATURE_SIZE = 64;
+const SECP256R1_SPKI_HEADER = new Uint8Array([
+  48,
+  89,
+  // SEQUENCE, length 89
+  48,
+  19,
+  // SEQUENCE, length 19
+  6,
+  7,
+  // OID, length 7
+  42,
+  134,
+  72,
+  206,
+  61,
+  2,
+  1,
+  // OID: 1.2.840.10045.2.1 (ecPublicKey)
+  6,
+  8,
+  // OID, length 8
+  42,
+  134,
+  72,
+  206,
+  61,
+  3,
+  1,
+  7,
+  // OID: 1.2.840.10045.3.1.7 (prime256v1/secp256r1)
+  3,
+  66,
+  // BIT STRING, length 66
+  0
+  // no unused bits
+]);
+class PasskeyPublicKey extends import_publickey.PublicKey {
+  /**
+   * Create a new PasskeyPublicKey object
+   * @param value passkey 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 !== PASSKEY_PUBLIC_KEY_SIZE) {
+      throw new Error(
+        `Invalid public key input. Expected ${PASSKEY_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`
+      );
+    }
+  }
+  /**
+   * Checks if two passkey 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["Passkey"];
+  }
+  /**
+   * Verifies that the signature is valid for for the provided message
+   */
+  async verify(message, signature) {
+    const parsed = parseSerializedPasskeySignature(signature);
+    const clientDataJSON = JSON.parse(parsed.clientDataJson);
+    if (clientDataJSON.type !== "webauthn.get") {
+      return false;
+    }
+    const parsedChallenge = (0, import_bcs.fromBase64)(
+      clientDataJSON.challenge.replace(/-/g, "+").replace(/_/g, "/")
+    );
+    if (!(0, import_publickey.bytesEqual)(message, parsedChallenge)) {
+      return false;
+    }
+    const pk = parsed.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE);
+    if (!(0, import_publickey.bytesEqual)(this.toRawBytes(), pk)) {
+      return false;
+    }
+    const payload = new Uint8Array([
+      ...parsed.authenticatorData,
+      ...(0, import_sha256.sha256)(parsed.clientDataJson)
+    ]);
+    const sig = parsed.userSignature.slice(1, PASSKEY_SIGNATURE_SIZE + 1);
+    return import_p256.secp256r1.verify(sig, (0, import_sha256.sha256)(payload), pk);
+  }
+}
+__publicField(PasskeyPublicKey, "SIZE", PASSKEY_PUBLIC_KEY_SIZE);
+function parseDerSPKI(derBytes) {
+  if (derBytes.length !== SECP256R1_SPKI_HEADER.length + PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE) {
+    throw new Error("Invalid DER length");
+  }
+  for (let i = 0; i < SECP256R1_SPKI_HEADER.length; i++) {
+    if (derBytes[i] !== SECP256R1_SPKI_HEADER[i]) {
+      throw new Error("Invalid spki header");
+    }
+  }
+  if (derBytes[SECP256R1_SPKI_HEADER.length] !== 4) {
+    throw new Error("Invalid point marker");
+  }
+  return derBytes.slice(SECP256R1_SPKI_HEADER.length);
+}
+function parseSerializedPasskeySignature(signature) {
+  const bytes = typeof signature === "string" ? (0, import_bcs.fromBase64)(signature) : signature;
+  if (bytes[0] !== import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG.Passkey) {
+    throw new Error("Invalid signature scheme");
+  }
+  const dec = import_bcs2.PasskeyAuthenticator.parse(bytes.slice(1));
+  return {
+    signatureScheme: "Passkey",
+    serializedSignature: (0, import_bcs.toBase64)(bytes),
+    signature: bytes,
+    authenticatorData: dec.authenticatorData,
+    clientDataJson: dec.clientDataJson,
+    userSignature: new Uint8Array(dec.userSignature),
+    publicKey: new Uint8Array(
+      dec.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE)
+    )
+  };
+}

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

@@ -0,0 +1,12 @@
+/**
+ * The value returned from navigator.credentials.get()
+ */
+export interface AuthenticationCredential extends PublicKeyCredential {
+    response: AuthenticatorAssertionResponse;
+}
+/**
+ * The value returned from navigator.credentials.create()
+ */
+export interface RegistrationCredential extends PublicKeyCredential {
+    response: AuthenticatorAttestationResponse;
+}

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

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,2 @@
+export { DEFAULT_SECP256K1_DERIVATION_PATH, Secp256k1Keypair, type Secp256k1KeypairData, } from "./keypair.js";
+export { Secp256k1PublicKey } from "./publickey.js";

package/dist/cjs/keypairs/secp256k1/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 secp256k1_exports = {};
+__export(secp256k1_exports, {
+  DEFAULT_SECP256K1_DERIVATION_PATH: () => import_keypair.DEFAULT_SECP256K1_DERIVATION_PATH,
+  Secp256k1Keypair: () => import_keypair.Secp256k1Keypair,
+  Secp256k1PublicKey: () => import_publickey.Secp256k1PublicKey
+});
+module.exports = __toCommonJS(secp256k1_exports);
+var import_keypair = require("./keypair.js");
+var import_publickey = require("./publickey.js");

package/dist/cjs/keypairs/secp256k1/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_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
+/**
+ * Secp256k1 Keypair data
+ */
+export interface Secp256k1KeypairData {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+/**
+ * An Secp256k1 Keypair used for signing transactions.
+ */
+export declare class Secp256k1Keypair extends Keypair {
+    private keypair;
+    /**
+     * Create a new keypair instance.
+     * Generate random keypair if no {@link Secp256k1Keypair} is provided.
+     *
+     * @param keypair secp256k1 keypair
+     */
+    constructor(keypair?: Secp256k1KeypairData);
+    /**
+     * Get the key scheme of the keypair Secp256k1
+     */
+    getKeyScheme(): SignatureScheme;
+    /**
+     * Generate a new random keypair
+     */
+    static generate(): 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: Uint8Array | string, options?: {
+        skipValidation?: boolean;
+    }): Secp256k1Keypair;
+    /**
+     * Generate a keypair from a 32 byte seed.
+     *
+     * @param seed seed byte array
+     */
+    static fromSeed(seed: Uint8Array): Secp256k1Keypair;
+    /**
+     * The public key for this keypair
+     */
+    getPublicKey(): PublicKey;
+    /**
+     * The Bech32 secret key string for this Secp256k1 keypair
+     */
+    getSecretKey(): string;
+    /**
+     * Return the signature for the provided data.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * 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: string, path?: string): Secp256k1Keypair;
+}