@haneullabs/haneul 0.1.0

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/keypairs/passkey/publickey.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64 } from '@haneullabs/bcs';\nimport { secp256r1 } from '@noble/curves/p256';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport { PasskeyAuthenticator } from '../../bcs/bcs.js';\nimport { bytesEqual, PublicKey } from '../../cryptography/publickey.js';\nimport type { PublicKeyInitData } from '../../cryptography/publickey.js';\nimport { SIGNATURE_SCHEME_TO_FLAG } from '../../cryptography/signature-scheme.js';\n\nexport const PASSKEY_PUBLIC_KEY_SIZE = 33;\nexport const PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;\nexport const PASSKEY_SIGNATURE_SIZE = 64;\n/** Fixed DER header for secp256r1 SubjectPublicKeyInfo\nDER structure for P-256 SPKI:\n30 -- SEQUENCE\n  59 -- length (89 bytes)\n  30 -- SEQUENCE\n    13 -- length (19 bytes)\n    06 -- OBJECT IDENTIFIER\n      07 -- length\n      2A 86 48 CE 3D 02 01 -- id-ecPublicKey\n    06 -- OBJECT IDENTIFIER\n      08 -- length\n      2A 86 48 CE 3D 03 01 07 -- secp256r1/prime256v1\n  03 -- BIT STRING\n    42 -- length (66 bytes)\n    00 -- padding\n\t===== above bytes are considered header =====\n    04 || x || y -- uncompressed point (65 bytes: 0x04 || 32-byte x || 32-byte y)\n*/\nexport const SECP256R1_SPKI_HEADER = new Uint8Array([\n\t0x30,\n\t0x59, // SEQUENCE, length 89\n\t0x30,\n\t0x13, // SEQUENCE, length 19\n\t0x06,\n\t0x07, // OID, length 7\n\t0x2a,\n\t0x86,\n\t0x48,\n\t0xce,\n\t0x3d,\n\t0x02,\n\t0x01, // OID: 1.2.840.10045.2.1 (ecPublicKey)\n\t0x06,\n\t0x08, // OID, length 8\n\t0x2a,\n\t0x86,\n\t0x48,\n\t0xce,\n\t0x3d,\n\t0x03,\n\t0x01,\n\t0x07, // OID: 1.2.840.10045.3.1.7 (prime256v1/secp256r1)\n\t0x03,\n\t0x42, // BIT STRING, length 66\n\t0x00, // no unused bits\n] as const);\n\n/**\n * A passkey public key\n */\nexport class PasskeyPublicKey extends PublicKey {\n\tstatic SIZE = PASSKEY_PUBLIC_KEY_SIZE;\n\tprivate data: Uint8Array<ArrayBuffer>;\n\n\t/**\n\t * Create a new PasskeyPublicKey object\n\t * @param value passkey public key as buffer or base-64 encoded string\n\t */\n\tconstructor(value: PublicKeyInitData) {\n\t\tsuper();\n\n\t\tif (typeof value === 'string') {\n\t\t\tthis.data = fromBase64(value);\n\t\t} else if (value instanceof Uint8Array) {\n\t\t\tthis.data = value as Uint8Array<ArrayBuffer>;\n\t\t} else {\n\t\t\tthis.data = Uint8Array.from(value);\n\t\t}\n\n\t\tif (this.data.length !== PASSKEY_PUBLIC_KEY_SIZE) {\n\t\t\tthrow new Error(\n\t\t\t\t`Invalid public key input. Expected ${PASSKEY_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Checks if two passkey public keys are equal\n\t */\n\toverride equals(publicKey: PasskeyPublicKey): boolean {\n\t\treturn super.equals(publicKey);\n\t}\n\n\t/**\n\t * Return the byte array representation of the Secp256r1 public key\n\t */\n\ttoRawBytes(): Uint8Array<ArrayBuffer> {\n\t\treturn this.data;\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this Secp256r1 public key\n\t */\n\tflag(): number {\n\t\treturn SIGNATURE_SCHEME_TO_FLAG['Passkey'];\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided message\n\t */\n\tasync verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\tconst parsed = parseSerializedPasskeySignature(signature);\n\t\tconst clientDataJSON = JSON.parse(parsed.clientDataJson);\n\n\t\tif (clientDataJSON.type !== 'webauthn.get') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// parse challenge from base64 url\n\t\tconst parsedChallenge = fromBase64(\n\t\t\tclientDataJSON.challenge.replace(/-/g, '+').replace(/_/g, '/'),\n\t\t);\n\t\tif (!bytesEqual(message, parsedChallenge)) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst pk = parsed.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE);\n\t\tif (!bytesEqual(this.toRawBytes(), pk)) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst payload = new Uint8Array([...parsed.authenticatorData, ...sha256(parsed.clientDataJson)]);\n\t\tconst sig = parsed.userSignature.slice(1, PASSKEY_SIGNATURE_SIZE + 1);\n\t\treturn secp256r1.verify(sig, sha256(payload), pk);\n\t}\n}\n\n/**\n * Parses a DER SubjectPublicKeyInfo into an uncompressed public key. This also verifies\n * that the curve used is P-256 (secp256r1).\n *\n * @param data: DER SubjectPublicKeyInfo\n * @returns uncompressed public key (`0x04 || x || y`)\n */\nexport function parseDerSPKI(derBytes: Uint8Array): Uint8Array {\n\t// Verify length and header bytes are expected\n\tif (derBytes.length !== SECP256R1_SPKI_HEADER.length + PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE) {\n\t\tthrow new Error('Invalid DER length');\n\t}\n\tfor (let i = 0; i < SECP256R1_SPKI_HEADER.length; i++) {\n\t\tif (derBytes[i] !== SECP256R1_SPKI_HEADER[i]) {\n\t\t\tthrow new Error('Invalid spki header');\n\t\t}\n\t}\n\n\tif (derBytes[SECP256R1_SPKI_HEADER.length] !== 0x04) {\n\t\tthrow new Error('Invalid point marker');\n\t}\n\n\t// Returns the last 65 bytes `04 || x || y`\n\treturn derBytes.slice(SECP256R1_SPKI_HEADER.length);\n}\n\n/**\n * Parse signature from bytes or base64 string into the following fields.\n */\nexport function parseSerializedPasskeySignature(signature: Uint8Array | string) {\n\tconst bytes = typeof signature === 'string' ? fromBase64(signature) : signature;\n\n\tif (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.Passkey) {\n\t\tthrow new Error('Invalid signature scheme');\n\t}\n\tconst dec = PasskeyAuthenticator.parse(bytes.slice(1));\n\treturn {\n\t\tsignatureScheme: 'Passkey' as const,\n\t\tserializedSignature: toBase64(bytes),\n\t\tsignature: bytes,\n\t\tauthenticatorData: dec.authenticatorData,\n\t\tclientDataJson: dec.clientDataJson,\n\t\tuserSignature: new Uint8Array(dec.userSignature),\n\t\tpublicKey: new Uint8Array(dec.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE)),\n\t};\n}\n"],
+  "mappings": "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",
+  "names": ["import_bcs"]
+}

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,17 @@
+"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);
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/keypairs/passkey/types.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The value returned from navigator.credentials.get()\n */\nexport interface AuthenticationCredential extends PublicKeyCredential {\n\tresponse: AuthenticatorAssertionResponse;\n}\n\n/**\n * The value returned from navigator.credentials.create()\n */\nexport interface RegistrationCredential extends PublicKeyCredential {\n\tresponse: AuthenticatorAttestationResponse;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

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,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 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");
+//# sourceMappingURL=index.js.map

package/dist/cjs/keypairs/secp256k1/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/keypairs/secp256k1/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n\tDEFAULT_SECP256K1_DERIVATION_PATH,\n\tSecp256k1Keypair,\n\ttype Secp256k1KeypairData,\n} from './keypair.js';\nexport { Secp256k1PublicKey } from './publickey.js';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,qBAIO;AACP,uBAAmC;",
+  "names": []
+}

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;
+}

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

@@ -0,0 +1,150 @@
+"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, {
+  DEFAULT_SECP256K1_DERIVATION_PATH: () => DEFAULT_SECP256K1_DERIVATION_PATH,
+  Secp256k1Keypair: () => Secp256k1Keypair
+});
+module.exports = __toCommonJS(keypair_exports);
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_utils = require("@noble/hashes/utils");
+var import_bip32 = require("@scure/bip32");
+var import_keypair = require("../../cryptography/keypair.js");
+var import_mnemonics = require("../../cryptography/mnemonics.js");
+var import_publickey = require("./publickey.js");
+const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
+class Secp256k1Keypair extends import_keypair.Keypair {
+  /**
+   * Create a new keypair instance.
+   * Generate random keypair if no {@link Secp256k1Keypair} is provided.
+   *
+   * @param keypair secp256k1 keypair
+   */
+  constructor(keypair) {
+    super();
+    if (keypair) {
+      this.keypair = keypair;
+    } else {
+      const secretKey = import_secp256k1.secp256k1.utils.randomPrivateKey();
+      const publicKey = import_secp256k1.secp256k1.getPublicKey(secretKey, true);
+      this.keypair = { publicKey, secretKey };
+    }
+  }
+  /**
+   * Get the key scheme of the keypair Secp256k1
+   */
+  getKeyScheme() {
+    return "Secp256k1";
+  }
+  /**
+   * Generate a new random keypair
+   */
+  static generate() {
+    return new Secp256k1Keypair();
+  }
+  /**
+   * Create a keypair from a raw secret key byte array.
+   *
+   * This method should only be used to recreate a keypair from a previously
+   * generated secret key. Generating keypairs from a random seed should be done
+   * with the {@link Keypair.fromSeed} method.
+   *
+   * @throws error if the provided secret key is invalid and validation is not skipped.
+   *
+   * @param secretKey secret key byte array  or Bech32 secret key string
+   * @param options: skip secret key validation
+   */
+  static fromSecretKey(secretKey, options) {
+    if (typeof secretKey === "string") {
+      const decoded = (0, import_keypair.decodeHaneulPrivateKey)(secretKey);
+      if (decoded.schema !== "Secp256k1") {
+        throw new Error(`Expected a Secp256k1 keypair, got ${decoded.schema}`);
+      }
+      return this.fromSecretKey(decoded.secretKey, options);
+    }
+    const publicKey = import_secp256k1.secp256k1.getPublicKey(secretKey, true);
+    if (!options || !options.skipValidation) {
+      const encoder = new TextEncoder();
+      const signData = encoder.encode("sui validation");
+      const msgHash = (0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(signData, { dkLen: 32 }));
+      const signature = import_secp256k1.secp256k1.sign(msgHash, secretKey);
+      if (!import_secp256k1.secp256k1.verify(signature, msgHash, publicKey, { lowS: true })) {
+        throw new Error("Provided secretKey is invalid");
+      }
+    }
+    return new Secp256k1Keypair({ publicKey, secretKey });
+  }
+  /**
+   * Generate a keypair from a 32 byte seed.
+   *
+   * @param seed seed byte array
+   */
+  static fromSeed(seed) {
+    const publicKey = import_secp256k1.secp256k1.getPublicKey(seed, true);
+    return new Secp256k1Keypair({ publicKey, secretKey: seed });
+  }
+  /**
+   * The public key for this keypair
+   */
+  getPublicKey() {
+    return new import_publickey.Secp256k1PublicKey(this.keypair.publicKey);
+  }
+  /**
+   * The Bech32 secret key string for this Secp256k1 keypair
+   */
+  getSecretKey() {
+    return (0, import_keypair.encodeHaneulPrivateKey)(this.keypair.secretKey, this.getKeyScheme());
+  }
+  /**
+   * Return the signature for the provided data.
+   */
+  async sign(data) {
+    const msgHash = (0, import_sha256.sha256)(data);
+    const sig = import_secp256k1.secp256k1.sign(msgHash, this.keypair.secretKey, {
+      lowS: true
+    });
+    return sig.toCompactRawBytes();
+  }
+  /**
+   * Derive Secp256k1 keypair from mnemonics and path. The mnemonics must be normalized
+   * and validated against the english wordlist.
+   *
+   * If path is none, it will default to m/54'/784'/0'/0/0, otherwise the path must
+   * be compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}.
+   */
+  static deriveKeypair(mnemonics, path) {
+    if (path == null) {
+      path = DEFAULT_SECP256K1_DERIVATION_PATH;
+    }
+    if (!(0, import_mnemonics.isValidBIP32Path)(path)) {
+      throw new Error("Invalid derivation path");
+    }
+    const key = import_bip32.HDKey.fromMasterSeed((0, import_mnemonics.mnemonicToSeed)(mnemonics)).derive(path);
+    if (key.publicKey == null || key.privateKey == null) {
+      throw new Error("Invalid key");
+    }
+    return new Secp256k1Keypair({
+      publicKey: key.publicKey,
+      secretKey: key.privateKey
+    });
+  }
+}
+//# sourceMappingURL=keypair.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/keypairs/secp256k1/keypair.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { secp256k1 } from '@noble/curves/secp256k1';\nimport { blake2b } from '@noble/hashes/blake2b';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { bytesToHex } from '@noble/hashes/utils';\nimport { HDKey } from '@scure/bip32';\n\nimport { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from '../../cryptography/keypair.js';\nimport { isValidBIP32Path, mnemonicToSeed } from '../../cryptography/mnemonics.js';\nimport type { PublicKey } from '../../cryptography/publickey.js';\nimport type { SignatureScheme } from '../../cryptography/signature-scheme.js';\nimport { Secp256k1PublicKey } from './publickey.js';\n\nexport const DEFAULT_SECP256K1_DERIVATION_PATH = \"m/54'/784'/0'/0/0\";\n\n/**\n * Secp256k1 Keypair data\n */\nexport interface Secp256k1KeypairData {\n\tpublicKey: Uint8Array;\n\tsecretKey: Uint8Array;\n}\n\n/**\n * An Secp256k1 Keypair used for signing transactions.\n */\nexport class Secp256k1Keypair extends Keypair {\n\tprivate keypair: Secp256k1KeypairData;\n\n\t/**\n\t * Create a new keypair instance.\n\t * Generate random keypair if no {@link Secp256k1Keypair} is provided.\n\t *\n\t * @param keypair secp256k1 keypair\n\t */\n\tconstructor(keypair?: Secp256k1KeypairData) {\n\t\tsuper();\n\t\tif (keypair) {\n\t\t\tthis.keypair = keypair;\n\t\t} else {\n\t\t\tconst secretKey: Uint8Array = secp256k1.utils.randomPrivateKey();\n\t\t\tconst publicKey: Uint8Array = secp256k1.getPublicKey(secretKey, true);\n\n\t\t\tthis.keypair = { publicKey, secretKey };\n\t\t}\n\t}\n\n\t/**\n\t * Get the key scheme of the keypair Secp256k1\n\t */\n\tgetKeyScheme(): SignatureScheme {\n\t\treturn 'Secp256k1';\n\t}\n\n\t/**\n\t * Generate a new random keypair\n\t */\n\tstatic generate(): Secp256k1Keypair {\n\t\treturn new Secp256k1Keypair();\n\t}\n\n\t/**\n\t * Create a keypair from a raw secret key byte array.\n\t *\n\t * This method should only be used to recreate a keypair from a previously\n\t * generated secret key. Generating keypairs from a random seed should be done\n\t * with the {@link Keypair.fromSeed} method.\n\t *\n\t * @throws error if the provided secret key is invalid and validation is not skipped.\n\t *\n\t * @param secretKey secret key byte array  or Bech32 secret key string\n\t * @param options: skip secret key validation\n\t */\n\n\tstatic fromSecretKey(\n\t\tsecretKey: Uint8Array | string,\n\t\toptions?: { skipValidation?: boolean },\n\t): Secp256k1Keypair {\n\t\tif (typeof secretKey === 'string') {\n\t\t\tconst decoded = decodeHaneulPrivateKey(secretKey);\n\n\t\t\tif (decoded.schema !== 'Secp256k1') {\n\t\t\t\tthrow new Error(`Expected a Secp256k1 keypair, got ${decoded.schema}`);\n\t\t\t}\n\n\t\t\treturn this.fromSecretKey(decoded.secretKey, options);\n\t\t}\n\n\t\tconst publicKey: Uint8Array = secp256k1.getPublicKey(secretKey, true);\n\t\tif (!options || !options.skipValidation) {\n\t\t\tconst encoder = new TextEncoder();\n\t\t\tconst signData = encoder.encode('sui validation');\n\t\t\tconst msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));\n\t\t\tconst signature = secp256k1.sign(msgHash, secretKey);\n\t\t\tif (!secp256k1.verify(signature, msgHash, publicKey, { lowS: true })) {\n\t\t\t\tthrow new Error('Provided secretKey is invalid');\n\t\t\t}\n\t\t}\n\t\treturn new Secp256k1Keypair({ publicKey, secretKey });\n\t}\n\n\t/**\n\t * Generate a keypair from a 32 byte seed.\n\t *\n\t * @param seed seed byte array\n\t */\n\tstatic fromSeed(seed: Uint8Array): Secp256k1Keypair {\n\t\tconst publicKey = secp256k1.getPublicKey(seed, true);\n\t\treturn new Secp256k1Keypair({ publicKey, secretKey: seed });\n\t}\n\n\t/**\n\t * The public key for this keypair\n\t */\n\tgetPublicKey(): PublicKey {\n\t\treturn new Secp256k1PublicKey(this.keypair.publicKey);\n\t}\n\t/**\n\t * The Bech32 secret key string for this Secp256k1 keypair\n\t */\n\tgetSecretKey(): string {\n\t\treturn encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());\n\t}\n\n\t/**\n\t * Return the signature for the provided data.\n\t */\n\tasync sign(data: Uint8Array) {\n\t\tconst msgHash = sha256(data);\n\t\tconst sig = secp256k1.sign(msgHash, this.keypair.secretKey, {\n\t\t\tlowS: true,\n\t\t});\n\t\treturn sig.toCompactRawBytes() as Uint8Array<ArrayBuffer>;\n\t}\n\n\t/**\n\t * Derive Secp256k1 keypair from mnemonics and path. The mnemonics must be normalized\n\t * and validated against the english wordlist.\n\t *\n\t * If path is none, it will default to m/54'/784'/0'/0/0, otherwise the path must\n\t * be compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}.\n\t */\n\tstatic deriveKeypair(mnemonics: string, path?: string): Secp256k1Keypair {\n\t\tif (path == null) {\n\t\t\tpath = DEFAULT_SECP256K1_DERIVATION_PATH;\n\t\t}\n\t\tif (!isValidBIP32Path(path)) {\n\t\t\tthrow new Error('Invalid derivation path');\n\t\t}\n\t\tconst key = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path);\n\t\tif (key.publicKey == null || key.privateKey == null) {\n\t\t\tthrow new Error('Invalid key');\n\t\t}\n\t\treturn new Secp256k1Keypair({\n\t\t\tpublicKey: key.publicKey,\n\t\t\tsecretKey: key.privateKey,\n\t\t});\n\t}\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,30 @@
+import { PublicKey } from '../../cryptography/publickey.js';
+import type { PublicKeyInitData } from '../../cryptography/publickey.js';
+/**
+ * A Secp256k1 public key
+ */
+export declare class Secp256k1PublicKey extends PublicKey {
+    static SIZE: number;
+    private data;
+    /**
+     * Create a new Secp256k1PublicKey object
+     * @param value secp256k1 public key as buffer or base-64 encoded string
+     */
+    constructor(value: PublicKeyInitData);
+    /**
+     * Checks if two Secp256k1 public keys are equal
+     */
+    equals(publicKey: Secp256k1PublicKey): boolean;
+    /**
+     * Return the byte array representation of the Secp256k1 public key
+     */
+    toRawBytes(): Uint8Array<ArrayBuffer>;
+    /**
+     * Return the Haneul address associated with this Secp256k1 public key
+     */
+    flag(): number;
+    /**
+     * Verifies that the signature is valid for for the provided message
+     */
+    verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+}

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

@@ -0,0 +1,93 @@
+"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, {
+  Secp256k1PublicKey: () => Secp256k1PublicKey
+});
+module.exports = __toCommonJS(publickey_exports);
+var import_bcs = require("@haneullabs/bcs");
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_publickey = require("../../cryptography/publickey.js");
+var import_signature_scheme = require("../../cryptography/signature-scheme.js");
+const SECP256K1_PUBLIC_KEY_SIZE = 33;
+class Secp256k1PublicKey extends import_publickey.PublicKey {
+  /**
+   * Create a new Secp256k1PublicKey object
+   * @param value secp256k1 public key as buffer or base-64 encoded string
+   */
+  constructor(value) {
+    super();
+    if (typeof value === "string") {
+      this.data = (0, import_bcs.fromBase64)(value);
+    } else if (value instanceof Uint8Array) {
+      this.data = value;
+    } else {
+      this.data = Uint8Array.from(value);
+    }
+    if (this.data.length !== SECP256K1_PUBLIC_KEY_SIZE) {
+      throw new Error(
+        `Invalid public key input. Expected ${SECP256K1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`
+      );
+    }
+  }
+  /**
+   * Checks if two Secp256k1 public keys are equal
+   */
+  equals(publicKey) {
+    return super.equals(publicKey);
+  }
+  /**
+   * Return the byte array representation of the Secp256k1 public key
+   */
+  toRawBytes() {
+    return this.data;
+  }
+  /**
+   * Return the Haneul address associated with this Secp256k1 public key
+   */
+  flag() {
+    return import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG["Secp256k1"];
+  }
+  /**
+   * Verifies that the signature is valid for for the provided message
+   */
+  async verify(message, signature) {
+    let bytes;
+    if (typeof signature === "string") {
+      const parsed = (0, import_publickey.parseSerializedKeypairSignature)(signature);
+      if (parsed.signatureScheme !== "Secp256k1") {
+        throw new Error("Invalid signature scheme");
+      }
+      if (!(0, import_publickey.bytesEqual)(this.toRawBytes(), parsed.publicKey)) {
+        throw new Error("Signature does not match public key");
+      }
+      bytes = parsed.signature;
+    } else {
+      bytes = signature;
+    }
+    return import_secp256k1.secp256k1.verify(
+      import_secp256k1.secp256k1.Signature.fromCompact(bytes),
+      (0, import_sha256.sha256)(message),
+      this.toRawBytes()
+    );
+  }
+}
+Secp256k1PublicKey.SIZE = SECP256K1_PUBLIC_KEY_SIZE;
+//# sourceMappingURL=publickey.js.map

package/dist/cjs/keypairs/secp256k1/publickey.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/keypairs/secp256k1/publickey.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64 } from '@haneullabs/bcs';\nimport { secp256k1 } from '@noble/curves/secp256k1';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport {\n\tbytesEqual,\n\tparseSerializedKeypairSignature,\n\tPublicKey,\n} from '../../cryptography/publickey.js';\nimport type { PublicKeyInitData } from '../../cryptography/publickey.js';\nimport { SIGNATURE_SCHEME_TO_FLAG } from '../../cryptography/signature-scheme.js';\n\nconst SECP256K1_PUBLIC_KEY_SIZE = 33;\n\n/**\n * A Secp256k1 public key\n */\nexport class Secp256k1PublicKey extends PublicKey {\n\tstatic SIZE = SECP256K1_PUBLIC_KEY_SIZE;\n\tprivate data: Uint8Array<ArrayBuffer>;\n\n\t/**\n\t * Create a new Secp256k1PublicKey object\n\t * @param value secp256k1 public key as buffer or base-64 encoded string\n\t */\n\tconstructor(value: PublicKeyInitData) {\n\t\tsuper();\n\n\t\tif (typeof value === 'string') {\n\t\t\tthis.data = fromBase64(value);\n\t\t} else if (value instanceof Uint8Array) {\n\t\t\tthis.data = value as Uint8Array<ArrayBuffer>;\n\t\t} else {\n\t\t\tthis.data = Uint8Array.from(value);\n\t\t}\n\n\t\tif (this.data.length !== SECP256K1_PUBLIC_KEY_SIZE) {\n\t\t\tthrow new Error(\n\t\t\t\t`Invalid public key input. Expected ${SECP256K1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Checks if two Secp256k1 public keys are equal\n\t */\n\toverride equals(publicKey: Secp256k1PublicKey): boolean {\n\t\treturn super.equals(publicKey);\n\t}\n\n\t/**\n\t * Return the byte array representation of the Secp256k1 public key\n\t */\n\ttoRawBytes(): Uint8Array<ArrayBuffer> {\n\t\treturn this.data;\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this Secp256k1 public key\n\t */\n\tflag(): number {\n\t\treturn SIGNATURE_SCHEME_TO_FLAG['Secp256k1'];\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided message\n\t */\n\tasync verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\tlet bytes;\n\t\tif (typeof signature === 'string') {\n\t\t\tconst parsed = parseSerializedKeypairSignature(signature);\n\t\t\tif (parsed.signatureScheme !== 'Secp256k1') {\n\t\t\t\tthrow new Error('Invalid signature scheme');\n\t\t\t}\n\n\t\t\tif (!bytesEqual(this.toRawBytes(), parsed.publicKey)) {\n\t\t\t\tthrow new Error('Signature does not match public key');\n\t\t\t}\n\n\t\t\tbytes = parsed.signature;\n\t\t} else {\n\t\t\tbytes = signature;\n\t\t}\n\n\t\treturn secp256k1.verify(\n\t\t\tsecp256k1.Signature.fromCompact(bytes),\n\t\t\tsha256(message),\n\t\t\tthis.toRawBytes(),\n\t\t);\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,iBAA2B;AAC3B,uBAA0B;AAC1B,oBAAuB;AAEvB,uBAIO;AAEP,8BAAyC;AAEzC,MAAM,4BAA4B;AAK3B,MAAM,2BAA2B,2BAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAQjD,YAAY,OAA0B;AACrC,UAAM;AAEN,QAAI,OAAO,UAAU,UAAU;AAC9B,WAAK,WAAO,uBAAW,KAAK;AAAA,IAC7B,WAAW,iBAAiB,YAAY;AACvC,WAAK,OAAO;AAAA,IACb,OAAO;AACN,WAAK,OAAO,WAAW,KAAK,KAAK;AAAA,IAClC;AAEA,QAAI,KAAK,KAAK,WAAW,2BAA2B;AACnD,YAAM,IAAI;AAAA,QACT,sCAAsC,yBAAyB,eAAe,KAAK,KAAK,MAAM;AAAA,MAC/F;AAAA,IACD;AAAA,EACD;AAAA;AAAA;AAAA;AAAA,EAKS,OAAO,WAAwC;AACvD,WAAO,MAAM,OAAO,SAAS;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA,EAKA,aAAsC;AACrC,WAAO,KAAK;AAAA,EACb;AAAA;AAAA;AAAA;AAAA,EAKA,OAAe;AACd,WAAO,iDAAyB,WAAW;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,OAAO,SAAqB,WAAkD;AACnF,QAAI;AACJ,QAAI,OAAO,cAAc,UAAU;AAClC,YAAM,aAAS,kDAAgC,SAAS;AACxD,UAAI,OAAO,oBAAoB,aAAa;AAC3C,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC3C;AAEA,UAAI,KAAC,6BAAW,KAAK,WAAW,GAAG,OAAO,SAAS,GAAG;AACrD,cAAM,IAAI,MAAM,qCAAqC;AAAA,MACtD;AAEA,cAAQ,OAAO;AAAA,IAChB,OAAO;AACN,cAAQ;AAAA,IACT;AAEA,WAAO,2BAAU;AAAA,MAChB,2BAAU,UAAU,YAAY,KAAK;AAAA,UACrC,sBAAO,OAAO;AAAA,MACd,KAAK,WAAW;AAAA,IACjB;AAAA,EACD;AACD;AAzEa,mBACL,OAAO;",
+  "names": []
+}

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

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

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

@@ -0,0 +1,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 secp256r1_exports = {};
+__export(secp256r1_exports, {
+  DEFAULT_SECP256R1_DERIVATION_PATH: () => import_keypair.DEFAULT_SECP256R1_DERIVATION_PATH,
+  Secp256r1Keypair: () => import_keypair.Secp256r1Keypair,
+  Secp256r1PublicKey: () => import_publickey.Secp256r1PublicKey
+});
+module.exports = __toCommonJS(secp256r1_exports);
+var import_keypair = require("./keypair.js");
+var import_publickey = require("./publickey.js");
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/keypairs/secp256r1/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n\tDEFAULT_SECP256R1_DERIVATION_PATH,\n\tSecp256r1Keypair,\n\ttype Secp256r1KeypairData,\n} from './keypair.js';\nexport { Secp256r1PublicKey } from './publickey.js';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,qBAIO;AACP,uBAAmC;",
+  "names": []
+}

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

@@ -0,0 +1,73 @@
+import { Keypair } from '../../cryptography/keypair.js';
+import type { PublicKey } from '../../cryptography/publickey.js';
+import type { SignatureScheme } from '../../cryptography/signature-scheme.js';
+export declare const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
+/**
+ * Secp256r1 Keypair data
+ */
+export interface Secp256r1KeypairData {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+/**
+ * An Secp256r1 Keypair used for signing transactions.
+ */
+export declare class Secp256r1Keypair extends Keypair {
+    private keypair;
+    /**
+     * Create a new keypair instance.
+     * Generate random keypair if no {@link Secp256r1Keypair} is provided.
+     *
+     * @param keypair Secp256r1 keypair
+     */
+    constructor(keypair?: Secp256r1KeypairData);
+    /**
+     * Get the key scheme of the keypair Secp256r1
+     */
+    getKeyScheme(): SignatureScheme;
+    /**
+     * Generate a new random keypair
+     */
+    static generate(): Secp256r1Keypair;
+    /**
+     * Create a keypair from a raw secret key byte array.
+     *
+     * This method should only be used to recreate a keypair from a previously
+     * generated secret key. Generating keypairs from a random seed should be done
+     * with the {@link Keypair.fromSeed} method.
+     *
+     * @throws error if the provided secret key is invalid and validation is not skipped.
+     *
+     * @param secretKey secret key byte array or Bech32 secret key string
+     * @param options: skip secret key validation
+     */
+    static fromSecretKey(secretKey: Uint8Array | string, options?: {
+        skipValidation?: boolean;
+    }): Secp256r1Keypair;
+    /**
+     * Generate a keypair from a 32 byte seed.
+     *
+     * @param seed seed byte array
+     */
+    static fromSeed(seed: Uint8Array): Secp256r1Keypair;
+    /**
+     * The public key for this keypair
+     */
+    getPublicKey(): PublicKey;
+    /**
+     * The Bech32 secret key string for this Secp256r1 keypair
+     */
+    getSecretKey(): string;
+    /**
+     * Return the signature for the provided data.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * Derive Secp256r1 keypair from mnemonics and path. The mnemonics must be normalized
+     * and validated against the english wordlist.
+     *
+     * If path is none, it will default to m/74'/784'/0'/0/0, otherwise the path must
+     * be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.
+     */
+    static deriveKeypair(mnemonics: string, path?: string): Secp256r1Keypair;
+}