@haneullabs/haneul 0.1.0 → 2.5.0

package/dist/keypairs/secp256k1/keypair.mjs

@@ -0,0 +1,125 @@
+import { isValidBIP32Path, mnemonicToSeed } from "../../cryptography/mnemonics.mjs";
+import { Keypair, decodeSuiPrivateKey, encodeSuiPrivateKey } from "../../cryptography/keypair.mjs";
+import { Secp256k1PublicKey } from "./publickey.mjs";
+import { blake2b } from "@noble/hashes/blake2.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { HDKey } from "@scure/bip32";
+
+//#region src/keypairs/secp256k1/keypair.ts
+const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
+/**
+* An Secp256k1 Keypair used for signing transactions.
+*/
+var Secp256k1Keypair = class Secp256k1Keypair extends Keypair {
+	/**
+	* Create a new keypair instance.
+	* Generate random keypair if no {@link Secp256k1Keypair} is provided.
+	*
+	* @param keypair secp256k1 keypair
+	*/
+	constructor(keypair) {
+		super();
+		if (keypair) this.keypair = keypair;
+		else {
+			const secretKey = secp256k1.utils.randomSecretKey();
+			this.keypair = {
+				publicKey: secp256k1.getPublicKey(secretKey, true),
+				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 = decodeSuiPrivateKey(secretKey);
+			if (decoded.scheme !== "Secp256k1") throw new Error(`Expected a Secp256k1 keypair, got ${decoded.scheme}`);
+			return this.fromSecretKey(decoded.secretKey, options);
+		}
+		const publicKey = secp256k1.getPublicKey(secretKey, true);
+		if (!options || !options.skipValidation) {
+			const msgHash = blake2b(new TextEncoder().encode("haneul validation"), { dkLen: 32 });
+			const signature = secp256k1.sign(msgHash, secretKey, { prehash: false });
+			if (!secp256k1.verify(signature, msgHash, publicKey, {
+				lowS: true,
+				prehash: false
+			})) 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) {
+		return new Secp256k1Keypair({
+			publicKey: secp256k1.getPublicKey(seed, true),
+			secretKey: seed
+		});
+	}
+	/**
+	* The public key for this keypair
+	*/
+	getPublicKey() {
+		return new Secp256k1PublicKey(this.keypair.publicKey);
+	}
+	/**
+	* The Bech32 secret key string for this Secp256k1 keypair
+	*/
+	getSecretKey() {
+		return encodeSuiPrivateKey(this.keypair.secretKey, this.getKeyScheme());
+	}
+	/**
+	* Return the signature for the provided data.
+	*/
+	async sign(data) {
+		return secp256k1.sign(data, this.keypair.secretKey, { lowS: true });
+	}
+	/**
+	* Derive Secp256k1 keypair from mnemonics and path. The mnemonics must be normalized
+	* and validated against the english wordlist.
+	*
+	* If path is none, it will default to m/54'/784'/0'/0/0, otherwise the path must
+	* be compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}.
+	*/
+	static deriveKeypair(mnemonics, path) {
+		if (path == null) path = DEFAULT_SECP256K1_DERIVATION_PATH;
+		if (!isValidBIP32Path(path)) throw new Error("Invalid derivation path");
+		const key = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path);
+		if (key.publicKey == null || key.privateKey == null) throw new Error("Invalid key");
+		return new Secp256k1Keypair({
+			publicKey: key.publicKey,
+			secretKey: key.privateKey
+		});
+	}
+};
+
+//#endregion
+export { DEFAULT_SECP256K1_DERIVATION_PATH, Secp256k1Keypair };
+//# sourceMappingURL=keypair.mjs.map

package/dist/keypairs/secp256k1/keypair.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.mjs","names":[],"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.js';\nimport { blake2b } from '@noble/hashes/blake2.js';\nimport { HDKey } from '@scure/bip32';\n\nimport { decodeSuiPrivateKey, encodeSuiPrivateKey, 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.randomSecretKey();\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 = decodeSuiPrivateKey(secretKey);\n\n\t\t\tif (decoded.scheme !== 'Secp256k1') {\n\t\t\t\tthrow new Error(`Expected a Secp256k1 keypair, got ${decoded.scheme}`);\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('haneul validation');\n\t\t\tconst msgHash = blake2b(signData, { dkLen: 32 });\n\t\t\tconst signature = secp256k1.sign(msgHash, secretKey, { prehash: false });\n\n\t\t\tif (!secp256k1.verify(signature, msgHash, publicKey, { lowS: true, prehash: false })) {\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 encodeSuiPrivateKey(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\treturn secp256k1.sign(data, this.keypair.secretKey, {\n\t\t\tlowS: true,\n\t\t}) 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":";;;;;;;;AAaA,MAAa,oCAAoC;;;;AAajD,IAAa,mBAAb,MAAa,yBAAyB,QAAQ;;;;;;;CAS7C,YAAY,SAAgC;AAC3C,SAAO;AACP,MAAI,QACH,MAAK,UAAU;OACT;GACN,MAAM,YAAwB,UAAU,MAAM,iBAAiB;AAG/D,QAAK,UAAU;IAAE,WAFa,UAAU,aAAa,WAAW,KAAK;IAEzC;IAAW;;;;;;CAOzC,eAAgC;AAC/B,SAAO;;;;;CAMR,OAAO,WAA6B;AACnC,SAAO,IAAI,kBAAkB;;;;;;;;;;;;;;CAgB9B,OAAO,cACN,WACA,SACmB;AACnB,MAAI,OAAO,cAAc,UAAU;GAClC,MAAM,UAAU,oBAAoB,UAAU;AAE9C,OAAI,QAAQ,WAAW,YACtB,OAAM,IAAI,MAAM,qCAAqC,QAAQ,SAAS;AAGvE,UAAO,KAAK,cAAc,QAAQ,WAAW,QAAQ;;EAGtD,MAAM,YAAwB,UAAU,aAAa,WAAW,KAAK;AACrE,MAAI,CAAC,WAAW,CAAC,QAAQ,gBAAgB;GAGxC,MAAM,UAAU,QAFA,IAAI,aAAa,CACR,OAAO,oBAAoB,EAClB,EAAE,OAAO,IAAI,CAAC;GAChD,MAAM,YAAY,UAAU,KAAK,SAAS,WAAW,EAAE,SAAS,OAAO,CAAC;AAExE,OAAI,CAAC,UAAU,OAAO,WAAW,SAAS,WAAW;IAAE,MAAM;IAAM,SAAS;IAAO,CAAC,CACnF,OAAM,IAAI,MAAM,gCAAgC;;AAGlD,SAAO,IAAI,iBAAiB;GAAE;GAAW;GAAW,CAAC;;;;;;;CAQtD,OAAO,SAAS,MAAoC;AAEnD,SAAO,IAAI,iBAAiB;GAAE,WADZ,UAAU,aAAa,MAAM,KAAK;GACX,WAAW;GAAM,CAAC;;;;;CAM5D,eAA0B;AACzB,SAAO,IAAI,mBAAmB,KAAK,QAAQ,UAAU;;;;;CAKtD,eAAuB;AACtB,SAAO,oBAAoB,KAAK,QAAQ,WAAW,KAAK,cAAc,CAAC;;;;;CAMxE,MAAM,KAAK,MAAkB;AAC5B,SAAO,UAAU,KAAK,MAAM,KAAK,QAAQ,WAAW,EACnD,MAAM,MACN,CAAC;;;;;;;;;CAUH,OAAO,cAAc,WAAmB,MAAiC;AACxE,MAAI,QAAQ,KACX,QAAO;AAER,MAAI,CAAC,iBAAiB,KAAK,CAC1B,OAAM,IAAI,MAAM,0BAA0B;EAE3C,MAAM,MAAM,MAAM,eAAe,eAAe,UAAU,CAAC,CAAC,OAAO,KAAK;AACxE,MAAI,IAAI,aAAa,QAAQ,IAAI,cAAc,KAC9C,OAAM,IAAI,MAAM,cAAc;AAE/B,SAAO,IAAI,iBAAiB;GAC3B,WAAW,IAAI;GACf,WAAW,IAAI;GACf,CAAC"}

package/dist/keypairs/secp256k1/publickey.d.mts

@@ -0,0 +1,35 @@
+import { PublicKey, PublicKeyInitData } from "../../cryptography/publickey.mjs";
+
+//#region src/keypairs/secp256k1/publickey.d.ts
+
+/**
+ * A Secp256k1 public key
+ */
+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>;
+}
+//#endregion
+export { Secp256k1PublicKey };
+//# sourceMappingURL=publickey.d.mts.map

package/dist/keypairs/secp256k1/publickey.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.d.mts","names":[],"sources":["../../../src/keypairs/secp256k1/publickey.ts"],"sourcesContent":[],"mappings":";;;;;AAmBA;;AA6B4B,cA7Bf,kBAAA,SAA2B,SAAA,CA6BZ;EAOF,OAAA,IAAA,EAAA,MAAA;EAAX,QAAA,IAAA;EAcQ;;;;EAlD0B,WAAA,CAAA,KAAA,EAQ7B,iBAR6B;;;;oBA6BrB;;;;gBAOb,WAAW;;;;;;;;kBAcH,uBAAuB,sBAAsB"}

package/dist/keypairs/secp256k1/publickey.mjs

@@ -0,0 +1,61 @@
+import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.mjs";
+import { PublicKey, bytesEqual, parseSerializedKeypairSignature } from "../../cryptography/publickey.mjs";
+import { fromBase64 } from "@haneullabs/bcs";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+
+//#region src/keypairs/secp256k1/publickey.ts
+const SECP256K1_PUBLIC_KEY_SIZE = 33;
+/**
+* A Secp256k1 public key
+*/
+var Secp256k1PublicKey = class extends PublicKey {
+	static {
+		this.SIZE = SECP256K1_PUBLIC_KEY_SIZE;
+	}
+	/**
+	* 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 = 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 SIGNATURE_SCHEME_TO_FLAG["Secp256k1"];
+	}
+	/**
+	* Verifies that the signature is valid for for the provided message
+	*/
+	async verify(message, signature) {
+		let bytes;
+		if (typeof signature === "string") {
+			const parsed = parseSerializedKeypairSignature(signature);
+			if (parsed.signatureScheme !== "Secp256k1") throw new Error("Invalid signature scheme");
+			if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) throw new Error("Signature does not match public key");
+			bytes = parsed.signature;
+		} else bytes = signature;
+		return secp256k1.verify(bytes, message, this.toRawBytes());
+	}
+};
+
+//#endregion
+export { Secp256k1PublicKey };
+//# sourceMappingURL=publickey.mjs.map

package/dist/keypairs/secp256k1/publickey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.mjs","names":[],"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.js';\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(bytes, message, this.toRawBytes());\n\t}\n}\n"],"mappings":";;;;;;AAcA,MAAM,4BAA4B;;;;AAKlC,IAAa,qBAAb,cAAwC,UAAU;;cACnC;;;;;;CAOd,YAAY,OAA0B;AACrC,SAAO;AAEP,MAAI,OAAO,UAAU,SACpB,MAAK,OAAO,WAAW,MAAM;WACnB,iBAAiB,WAC3B,MAAK,OAAO;MAEZ,MAAK,OAAO,WAAW,KAAK,MAAM;AAGnC,MAAI,KAAK,KAAK,WAAW,0BACxB,OAAM,IAAI,MACT,sCAAsC,0BAA0B,cAAc,KAAK,KAAK,SACxF;;;;;CAOH,AAAS,OAAO,WAAwC;AACvD,SAAO,MAAM,OAAO,UAAU;;;;;CAM/B,aAAsC;AACrC,SAAO,KAAK;;;;;CAMb,OAAe;AACd,SAAO,yBAAyB;;;;;CAMjC,MAAM,OAAO,SAAqB,WAAkD;EACnF,IAAI;AACJ,MAAI,OAAO,cAAc,UAAU;GAClC,MAAM,SAAS,gCAAgC,UAAU;AACzD,OAAI,OAAO,oBAAoB,YAC9B,OAAM,IAAI,MAAM,2BAA2B;AAG5C,OAAI,CAAC,WAAW,KAAK,YAAY,EAAE,OAAO,UAAU,CACnD,OAAM,IAAI,MAAM,sCAAsC;AAGvD,WAAQ,OAAO;QAEf,SAAQ;AAGT,SAAO,UAAU,OAAO,OAAO,SAAS,KAAK,YAAY,CAAC"}

package/dist/keypairs/secp256r1/index.d.mts

@@ -0,0 +1,3 @@
+import { DEFAULT_SECP256R1_DERIVATION_PATH, Secp256r1Keypair, Secp256r1KeypairData } from "./keypair.mjs";
+import { Secp256r1PublicKey } from "./publickey.mjs";
+export { DEFAULT_SECP256R1_DERIVATION_PATH, Secp256r1Keypair, type Secp256r1KeypairData, Secp256r1PublicKey };

package/dist/keypairs/secp256r1/index.mjs

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

package/dist/keypairs/secp256r1/keypair.d.mts

@@ -0,0 +1,78 @@
+import { PublicKey } from "../../cryptography/publickey.mjs";
+import { SignatureScheme } from "../../cryptography/signature-scheme.mjs";
+import { Keypair } from "../../cryptography/keypair.mjs";
+
+//#region src/keypairs/secp256r1/keypair.d.ts
+declare const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
+/**
+ * Secp256r1 Keypair data
+ */
+interface Secp256r1KeypairData {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+}
+/**
+ * An Secp256r1 Keypair used for signing transactions.
+ */
+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;
+}
+//#endregion
+export { DEFAULT_SECP256R1_DERIVATION_PATH, Secp256r1Keypair, Secp256r1KeypairData };
+//# sourceMappingURL=keypair.d.mts.map

package/dist/keypairs/secp256r1/keypair.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.d.mts","names":[],"sources":["../../../src/keypairs/secp256r1/keypair.ts"],"sourcesContent":[],"mappings":";;;;;cAaa,iCAAA;;AAAb;AAKA;AAQa,UARI,oBAAA,CAQa;EASP,SAAA,EAhBX,UAgBW;EAeN,SAAA,EA9BL,UA8BK;;;;;AAyDmB,cAjFvB,gBAAA,SAAyB,OAAA,CAiFF;EAQnB,QAAA,OAAA;EAcC;;;;;;EAvG2B,WAAA,CAAA,OAAA,CAAA,EAStB,oBATsB;;;;kBAwB5B;;;;qBAOG;;;;;;;;;;;;;kCAkBP;;MAET;;;;;;wBA8BmB,aAAa;;;;kBAQnB;;;;;;;;aAcC,aAAU,QAAA,WAAA;;;;;;;;0DAa6B"}

package/dist/keypairs/secp256r1/keypair.mjs

@@ -0,0 +1,124 @@
+import { isValidBIP32Path, mnemonicToSeed } from "../../cryptography/mnemonics.mjs";
+import { Keypair, decodeSuiPrivateKey, encodeSuiPrivateKey } from "../../cryptography/keypair.mjs";
+import { Secp256r1PublicKey } from "./publickey.mjs";
+import { blake2b } from "@noble/hashes/blake2.js";
+import { p256 } from "@noble/curves/nist.js";
+import { HDKey } from "@scure/bip32";
+
+//#region src/keypairs/secp256r1/keypair.ts
+const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
+/**
+* An Secp256r1 Keypair used for signing transactions.
+*/
+var Secp256r1Keypair = class Secp256r1Keypair extends Keypair {
+	/**
+	* Create a new keypair instance.
+	* Generate random keypair if no {@link Secp256r1Keypair} is provided.
+	*
+	* @param keypair Secp256r1 keypair
+	*/
+	constructor(keypair) {
+		super();
+		if (keypair) this.keypair = keypair;
+		else {
+			const secretKey = p256.utils.randomSecretKey();
+			this.keypair = {
+				publicKey: p256.getPublicKey(secretKey, true),
+				secretKey
+			};
+		}
+	}
+	/**
+	* Get the key scheme of the keypair Secp256r1
+	*/
+	getKeyScheme() {
+		return "Secp256r1";
+	}
+	/**
+	* Generate a new random keypair
+	*/
+	static generate() {
+		return new Secp256r1Keypair();
+	}
+	/**
+	* Create a keypair from a raw secret key byte array.
+	*
+	* This method should only be used to recreate a keypair from a previously
+	* generated secret key. Generating keypairs from a random seed should be done
+	* with the {@link Keypair.fromSeed} method.
+	*
+	* @throws error if the provided secret key is invalid and validation is not skipped.
+	*
+	* @param secretKey secret key byte array or Bech32 secret key string
+	* @param options: skip secret key validation
+	*/
+	static fromSecretKey(secretKey, options) {
+		if (typeof secretKey === "string") {
+			const decoded = decodeSuiPrivateKey(secretKey);
+			if (decoded.scheme !== "Secp256r1") throw new Error(`Expected a Secp256r1 keypair, got ${decoded.scheme}`);
+			return this.fromSecretKey(decoded.secretKey, options);
+		}
+		const publicKey = p256.getPublicKey(secretKey, true);
+		if (!options || !options.skipValidation) {
+			const msgHash = blake2b(new TextEncoder().encode("haneul validation"), { dkLen: 32 });
+			const signature = p256.sign(msgHash, secretKey, {
+				lowS: true,
+				prehash: false
+			});
+			if (!p256.verify(signature, msgHash, publicKey, {
+				lowS: true,
+				prehash: false
+			})) throw new Error("Provided secretKey is invalid");
+		}
+		return new Secp256r1Keypair({
+			publicKey,
+			secretKey
+		});
+	}
+	/**
+	* Generate a keypair from a 32 byte seed.
+	*
+	* @param seed seed byte array
+	*/
+	static fromSeed(seed) {
+		return new Secp256r1Keypair({
+			publicKey: p256.getPublicKey(seed, true),
+			secretKey: seed
+		});
+	}
+	/**
+	* The public key for this keypair
+	*/
+	getPublicKey() {
+		return new Secp256r1PublicKey(this.keypair.publicKey);
+	}
+	/**
+	* The Bech32 secret key string for this Secp256r1 keypair
+	*/
+	getSecretKey() {
+		return encodeSuiPrivateKey(this.keypair.secretKey, this.getKeyScheme());
+	}
+	/**
+	* Return the signature for the provided data.
+	*/
+	async sign(data) {
+		return p256.sign(data, this.keypair.secretKey, { lowS: true });
+	}
+	/**
+	* Derive Secp256r1 keypair from mnemonics and path. The mnemonics must be normalized
+	* and validated against the english wordlist.
+	*
+	* If path is none, it will default to m/74'/784'/0'/0/0, otherwise the path must
+	* be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.
+	*/
+	static deriveKeypair(mnemonics, path) {
+		if (path == null) path = DEFAULT_SECP256R1_DERIVATION_PATH;
+		if (!isValidBIP32Path(path)) throw new Error("Invalid derivation path");
+		const privateKey = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path).privateKey;
+		return Secp256r1Keypair.fromSecretKey(privateKey);
+	}
+};
+
+//#endregion
+export { DEFAULT_SECP256R1_DERIVATION_PATH, Secp256r1Keypair };
+//# sourceMappingURL=keypair.mjs.map

package/dist/keypairs/secp256r1/keypair.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.mjs","names":["secp256r1"],"sources":["../../../src/keypairs/secp256r1/keypair.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { p256 as secp256r1 } from '@noble/curves/nist.js';\nimport { blake2b } from '@noble/hashes/blake2.js';\nimport { HDKey } from '@scure/bip32';\n\nimport { decodeSuiPrivateKey, encodeSuiPrivateKey, 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 { Secp256r1PublicKey } from './publickey.js';\n\nexport const DEFAULT_SECP256R1_DERIVATION_PATH = \"m/74'/784'/0'/0/0\";\n\n/**\n * Secp256r1 Keypair data\n */\nexport interface Secp256r1KeypairData {\n\tpublicKey: Uint8Array;\n\tsecretKey: Uint8Array;\n}\n\n/**\n * An Secp256r1 Keypair used for signing transactions.\n */\nexport class Secp256r1Keypair extends Keypair {\n\tprivate keypair: Secp256r1KeypairData;\n\n\t/**\n\t * Create a new keypair instance.\n\t * Generate random keypair if no {@link Secp256r1Keypair} is provided.\n\t *\n\t * @param keypair Secp256r1 keypair\n\t */\n\tconstructor(keypair?: Secp256r1KeypairData) {\n\t\tsuper();\n\t\tif (keypair) {\n\t\t\tthis.keypair = keypair;\n\t\t} else {\n\t\t\tconst secretKey: Uint8Array = secp256r1.utils.randomSecretKey();\n\t\t\tconst publicKey: Uint8Array = secp256r1.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 Secp256r1\n\t */\n\tgetKeyScheme(): SignatureScheme {\n\t\treturn 'Secp256r1';\n\t}\n\n\t/**\n\t * Generate a new random keypair\n\t */\n\tstatic generate(): Secp256r1Keypair {\n\t\treturn new Secp256r1Keypair();\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): Secp256r1Keypair {\n\t\tif (typeof secretKey === 'string') {\n\t\t\tconst decoded = decodeSuiPrivateKey(secretKey);\n\n\t\t\tif (decoded.scheme !== 'Secp256r1') {\n\t\t\t\tthrow new Error(`Expected a Secp256r1 keypair, got ${decoded.scheme}`);\n\t\t\t}\n\n\t\t\treturn this.fromSecretKey(decoded.secretKey, options);\n\t\t}\n\n\t\tconst publicKey: Uint8Array = secp256r1.getPublicKey(secretKey, true);\n\t\tif (!options || !options.skipValidation) {\n\t\t\tconst encoder = new TextEncoder();\n\t\t\tconst signData = encoder.encode('haneul validation');\n\t\t\tconst msgHash = blake2b(signData, { dkLen: 32 });\n\t\t\tconst signature = secp256r1.sign(msgHash, secretKey, { lowS: true, prehash: false });\n\n\t\t\tif (!secp256r1.verify(signature, msgHash, publicKey, { lowS: true, prehash: false })) {\n\t\t\t\tthrow new Error('Provided secretKey is invalid');\n\t\t\t}\n\t\t}\n\t\treturn new Secp256r1Keypair({ 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): Secp256r1Keypair {\n\t\tconst publicKey = secp256r1.getPublicKey(seed, true);\n\t\treturn new Secp256r1Keypair({ 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 Secp256r1PublicKey(this.keypair.publicKey);\n\t}\n\n\t/**\n\t * The Bech32 secret key string for this Secp256r1 keypair\n\t */\n\tgetSecretKey(): string {\n\t\treturn encodeSuiPrivateKey(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\treturn secp256r1.sign(data, this.keypair.secretKey, {\n\t\t\tlowS: true,\n\t\t}) as Uint8Array<ArrayBuffer>;\n\t}\n\n\t/**\n\t * Derive Secp256r1 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/74'/784'/0'/0/0, otherwise the path must\n\t * be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.\n\t */\n\tstatic deriveKeypair(mnemonics: string, path?: string): Secp256r1Keypair {\n\t\tif (path == null) {\n\t\t\tpath = DEFAULT_SECP256R1_DERIVATION_PATH;\n\t\t}\n\t\tif (!isValidBIP32Path(path)) {\n\t\t\tthrow new Error('Invalid derivation path');\n\t\t}\n\t\t// We use HDKey which is hardcoded to use Secp256k1 but since we only need the 32 bytes for the private key it's okay to use here as well.\n\t\tconst privateKey = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path).privateKey;\n\t\treturn Secp256r1Keypair.fromSecretKey(privateKey!);\n\t}\n}\n"],"mappings":";;;;;;;;AAaA,MAAa,oCAAoC;;;;AAajD,IAAa,mBAAb,MAAa,yBAAyB,QAAQ;;;;;;;CAS7C,YAAY,SAAgC;AAC3C,SAAO;AACP,MAAI,QACH,MAAK,UAAU;OACT;GACN,MAAM,YAAwBA,KAAU,MAAM,iBAAiB;AAG/D,QAAK,UAAU;IAAE,WAFaA,KAAU,aAAa,WAAW,KAAK;IAEzC;IAAW;;;;;;CAOzC,eAAgC;AAC/B,SAAO;;;;;CAMR,OAAO,WAA6B;AACnC,SAAO,IAAI,kBAAkB;;;;;;;;;;;;;;CAgB9B,OAAO,cACN,WACA,SACmB;AACnB,MAAI,OAAO,cAAc,UAAU;GAClC,MAAM,UAAU,oBAAoB,UAAU;AAE9C,OAAI,QAAQ,WAAW,YACtB,OAAM,IAAI,MAAM,qCAAqC,QAAQ,SAAS;AAGvE,UAAO,KAAK,cAAc,QAAQ,WAAW,QAAQ;;EAGtD,MAAM,YAAwBA,KAAU,aAAa,WAAW,KAAK;AACrE,MAAI,CAAC,WAAW,CAAC,QAAQ,gBAAgB;GAGxC,MAAM,UAAU,QAFA,IAAI,aAAa,CACR,OAAO,oBAAoB,EAClB,EAAE,OAAO,IAAI,CAAC;GAChD,MAAM,YAAYA,KAAU,KAAK,SAAS,WAAW;IAAE,MAAM;IAAM,SAAS;IAAO,CAAC;AAEpF,OAAI,CAACA,KAAU,OAAO,WAAW,SAAS,WAAW;IAAE,MAAM;IAAM,SAAS;IAAO,CAAC,CACnF,OAAM,IAAI,MAAM,gCAAgC;;AAGlD,SAAO,IAAI,iBAAiB;GAAE;GAAW;GAAW,CAAC;;;;;;;CAQtD,OAAO,SAAS,MAAoC;AAEnD,SAAO,IAAI,iBAAiB;GAAE,WADZA,KAAU,aAAa,MAAM,KAAK;GACX,WAAW;GAAM,CAAC;;;;;CAM5D,eAA0B;AACzB,SAAO,IAAI,mBAAmB,KAAK,QAAQ,UAAU;;;;;CAMtD,eAAuB;AACtB,SAAO,oBAAoB,KAAK,QAAQ,WAAW,KAAK,cAAc,CAAC;;;;;CAMxE,MAAM,KAAK,MAAkB;AAC5B,SAAOA,KAAU,KAAK,MAAM,KAAK,QAAQ,WAAW,EACnD,MAAM,MACN,CAAC;;;;;;;;;CAUH,OAAO,cAAc,WAAmB,MAAiC;AACxE,MAAI,QAAQ,KACX,QAAO;AAER,MAAI,CAAC,iBAAiB,KAAK,CAC1B,OAAM,IAAI,MAAM,0BAA0B;EAG3C,MAAM,aAAa,MAAM,eAAe,eAAe,UAAU,CAAC,CAAC,OAAO,KAAK,CAAC;AAChF,SAAO,iBAAiB,cAAc,WAAY"}

package/dist/keypairs/secp256r1/publickey.d.mts

@@ -0,0 +1,35 @@
+import { PublicKey, PublicKeyInitData } from "../../cryptography/publickey.mjs";
+
+//#region src/keypairs/secp256r1/publickey.d.ts
+
+/**
+ * A Secp256r1 public key
+ */
+declare class Secp256r1PublicKey extends PublicKey {
+  static SIZE: number;
+  private data;
+  /**
+   * Create a new Secp256r1PublicKey object
+   * @param value secp256r1 public key as buffer or base-64 encoded string
+   */
+  constructor(value: PublicKeyInitData);
+  /**
+   * Checks if two Secp256r1 public keys are equal
+   */
+  equals(publicKey: Secp256r1PublicKey): boolean;
+  /**
+   * Return the byte array representation of the Secp256r1 public key
+   */
+  toRawBytes(): Uint8Array<ArrayBuffer>;
+  /**
+   * Return the Haneul 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>;
+}
+//#endregion
+export { Secp256r1PublicKey };
+//# sourceMappingURL=publickey.d.mts.map

package/dist/keypairs/secp256r1/publickey.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.d.mts","names":[],"sources":["../../../src/keypairs/secp256r1/publickey.ts"],"sourcesContent":[],"mappings":";;;;;AAgBA;;AA6B4B,cA7Bf,kBAAA,SAA2B,SAAA,CA6BZ;EAOF,OAAA,IAAA,EAAA,MAAA;EAAX,QAAA,IAAA;EAcQ;;;;EAlD0B,WAAA,CAAA,KAAA,EAQ7B,iBAR6B;;;;oBA6BrB;;;;gBAOb,WAAW;;;;;;;;kBAcH,uBAAuB,sBAAsB"}

package/dist/keypairs/secp256r1/publickey.mjs

@@ -0,0 +1,62 @@
+import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.mjs";
+import { PublicKey, bytesEqual } from "../../cryptography/publickey.mjs";
+import { parseSerializedSignature } from "../../cryptography/signature.mjs";
+import { fromBase64 } from "@haneullabs/bcs";
+import { p256 } from "@noble/curves/nist.js";
+
+//#region src/keypairs/secp256r1/publickey.ts
+const SECP256R1_PUBLIC_KEY_SIZE = 33;
+/**
+* A Secp256r1 public key
+*/
+var Secp256r1PublicKey = class extends PublicKey {
+	static {
+		this.SIZE = SECP256R1_PUBLIC_KEY_SIZE;
+	}
+	/**
+	* Create a new Secp256r1PublicKey object
+	* @param value secp256r1 public key as buffer or base-64 encoded string
+	*/
+	constructor(value) {
+		super();
+		if (typeof value === "string") this.data = fromBase64(value);
+		else if (value instanceof Uint8Array) this.data = value;
+		else this.data = Uint8Array.from(value);
+		if (this.data.length !== SECP256R1_PUBLIC_KEY_SIZE) throw new Error(`Invalid public key input. Expected ${SECP256R1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
+	}
+	/**
+	* Checks if two Secp256r1 public keys are equal
+	*/
+	equals(publicKey) {
+		return super.equals(publicKey);
+	}
+	/**
+	* Return the byte array representation of the Secp256r1 public key
+	*/
+	toRawBytes() {
+		return this.data;
+	}
+	/**
+	* Return the Haneul address associated with this Secp256r1 public key
+	*/
+	flag() {
+		return SIGNATURE_SCHEME_TO_FLAG["Secp256r1"];
+	}
+	/**
+	* Verifies that the signature is valid for for the provided message
+	*/
+	async verify(message, signature) {
+		let bytes;
+		if (typeof signature === "string") {
+			const parsed = parseSerializedSignature(signature);
+			if (parsed.signatureScheme !== "Secp256r1") throw new Error("Invalid signature scheme");
+			if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) throw new Error("Signature does not match public key");
+			bytes = parsed.signature;
+		} else bytes = signature;
+		return p256.verify(bytes, message, this.toRawBytes());
+	}
+};
+
+//#endregion
+export { Secp256r1PublicKey };
+//# sourceMappingURL=publickey.mjs.map

package/dist/keypairs/secp256r1/publickey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.mjs","names":["secp256r1"],"sources":["../../../src/keypairs/secp256r1/publickey.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64 } from '@haneullabs/bcs';\nimport { p256 as secp256r1 } from '@noble/curves/nist.js';\n\nimport { bytesEqual, PublicKey } from '../../cryptography/publickey.js';\nimport type { PublicKeyInitData } from '../../cryptography/publickey.js';\nimport { SIGNATURE_SCHEME_TO_FLAG } from '../../cryptography/signature-scheme.js';\nimport { parseSerializedSignature } from '../../cryptography/signature.js';\n\nconst SECP256R1_PUBLIC_KEY_SIZE = 33;\n\n/**\n * A Secp256r1 public key\n */\nexport class Secp256r1PublicKey extends PublicKey {\n\tstatic SIZE = SECP256R1_PUBLIC_KEY_SIZE;\n\tprivate data: Uint8Array<ArrayBuffer>;\n\n\t/**\n\t * Create a new Secp256r1PublicKey object\n\t * @param value secp256r1 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 !== SECP256R1_PUBLIC_KEY_SIZE) {\n\t\t\tthrow new Error(\n\t\t\t\t`Invalid public key input. Expected ${SECP256R1_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 Secp256r1 public keys are equal\n\t */\n\toverride equals(publicKey: Secp256r1PublicKey): 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['Secp256r1'];\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 = parseSerializedSignature(signature);\n\t\t\tif (parsed.signatureScheme !== 'Secp256r1') {\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 secp256r1.verify(bytes, message, this.toRawBytes());\n\t}\n}\n"],"mappings":";;;;;;;AAWA,MAAM,4BAA4B;;;;AAKlC,IAAa,qBAAb,cAAwC,UAAU;;cACnC;;;;;;CAOd,YAAY,OAA0B;AACrC,SAAO;AAEP,MAAI,OAAO,UAAU,SACpB,MAAK,OAAO,WAAW,MAAM;WACnB,iBAAiB,WAC3B,MAAK,OAAO;MAEZ,MAAK,OAAO,WAAW,KAAK,MAAM;AAGnC,MAAI,KAAK,KAAK,WAAW,0BACxB,OAAM,IAAI,MACT,sCAAsC,0BAA0B,cAAc,KAAK,KAAK,SACxF;;;;;CAOH,AAAS,OAAO,WAAwC;AACvD,SAAO,MAAM,OAAO,UAAU;;;;;CAM/B,aAAsC;AACrC,SAAO,KAAK;;;;;CAMb,OAAe;AACd,SAAO,yBAAyB;;;;;CAMjC,MAAM,OAAO,SAAqB,WAAkD;EACnF,IAAI;AACJ,MAAI,OAAO,cAAc,UAAU;GAClC,MAAM,SAAS,yBAAyB,UAAU;AAClD,OAAI,OAAO,oBAAoB,YAC9B,OAAM,IAAI,MAAM,2BAA2B;AAG5C,OAAI,CAAC,WAAW,KAAK,YAAY,EAAE,OAAO,UAAU,CACnD,OAAM,IAAI,MAAM,sCAAsC;AAGvD,WAAQ,OAAO;QAEf,SAAQ;AAGT,SAAOA,KAAU,OAAO,OAAO,SAAS,KAAK,YAAY,CAAC"}

package/dist/multisig/index.d.mts

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

package/dist/multisig/index.mjs

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