@haneullabs/haneul 0.1.0 → 2.5.0

package/dist/keypairs/passkey/keypair.mjs

@@ -0,0 +1,221 @@
+import { PasskeyAuthenticator } from "../../bcs/bcs.mjs";
+import { messageWithIntent } from "../../cryptography/intent.mjs";
+import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.mjs";
+import { PASSKEY_PUBLIC_KEY_SIZE, PASSKEY_SIGNATURE_SIZE, PasskeyPublicKey, parseDerSPKI } from "./publickey.mjs";
+import { Signer } from "../../cryptography/keypair.mjs";
+import { toBase64 } from "@haneullabs/bcs";
+import { blake2b } from "@noble/hashes/blake2.js";
+import { p256 } from "@noble/curves/nist.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+
+//#region src/keypairs/passkey/keypair.ts
+var BrowserPasskeyProvider = class {
+	#name;
+	#options;
+	constructor(name, options) {
+		this.#name = name;
+		this.#options = options;
+	}
+	async create() {
+		return await navigator.credentials.create({ publicKey: {
+			timeout: this.#options.timeout ?? 6e4,
+			...this.#options,
+			rp: {
+				name: this.#name,
+				...this.#options.rp
+			},
+			user: {
+				name: this.#name,
+				displayName: this.#name,
+				...this.#options.user,
+				id: randomBytes(10)
+			},
+			challenge: new TextEncoder().encode("Create passkey wallet on Haneul"),
+			pubKeyCredParams: [{
+				alg: -7,
+				type: "public-key"
+			}],
+			authenticatorSelection: {
+				authenticatorAttachment: "cross-platform",
+				residentKey: "required",
+				requireResidentKey: true,
+				userVerification: "required",
+				...this.#options.authenticatorSelection
+			}
+		} });
+	}
+	async get(challenge) {
+		return await navigator.credentials.get({ publicKey: {
+			challenge,
+			userVerification: this.#options.authenticatorSelection?.userVerification || "required",
+			timeout: this.#options.timeout ?? 6e4
+		} });
+	}
+};
+/**
+* @experimental
+* A passkey signer used for signing transactions. This is a client side implementation for [SIP-9](https://github.co./haneul-foundation/sips/blob/main/sips/sip-9.md).
+*/
+var PasskeyKeypair = class PasskeyKeypair extends Signer {
+	/**
+	* Get the key scheme of passkey,
+	*/
+	getKeyScheme() {
+		return "Passkey";
+	}
+	/**
+	* Creates an instance of Passkey signer. If no passkey wallet had created before,
+	* use `getPasskeyInstance`. For example:
+	* ```
+	* let provider = new BrowserPasskeyProvider('Haneul Passkey Example',{
+	* 	  rpName: 'Haneul 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();
+		this.publicKey = publicKey;
+		this.provider = provider;
+	}
+	/**
+	* 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 = parseDerSPKI(new Uint8Array(derSPKI));
+			return new PasskeyKeypair(p256.Point.fromBytes(pubkeyUncompressed).toBytes(true), provider);
+		}
+	}
+	/**
+	* Return the public key for this passkey.
+	*/
+	getPublicKey() {
+		return new 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 clientDataJSONString = new TextDecoder().decode(clientDataJSON);
+		const sig = p256.Signature.fromBytes(new Uint8Array(credential.response.signature), "der");
+		const normalized = (sig.hasHighS() ? new p256.Signature(sig.r, p256.Point.Fn.neg(sig.s)) : sig).toBytes("compact");
+		if (normalized.length !== PASSKEY_SIGNATURE_SIZE || this.publicKey.length !== 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([SIGNATURE_SCHEME_TO_FLAG["Secp256r1"]]);
+		arr.set(normalized, 1);
+		arr.set(this.publicKey, 1 + normalized.length);
+		return 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 digest = blake2b(messageWithIntent(intent, bytes), { dkLen: 32 });
+		const signature = await this.sign(digest);
+		const serializedSignature = new Uint8Array(1 + signature.length);
+		serializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[this.getKeyScheme()]]);
+		serializedSignature.set(signature, 1);
+		return {
+			signature: toBase64(serializedSignature),
+			bytes: 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('Haneul Passkey Example',{
+	*     rpName: 'Haneul 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 = p256.Signature.fromBytes(new Uint8Array(credential.response.signature), "der");
+		const res = [];
+		const msgHash = sha256(fullMessage);
+		for (let i = 0; i < 4; i++) {
+			const s = sig.addRecoveryBit(i);
+			try {
+				const pk = new PasskeyPublicKey(s.recoverPublicKey(msgHash).toBytes(true));
+				res.push(pk);
+			} catch {
+				continue;
+			}
+		}
+		return res;
+	}
+};
+/**
+* Finds the unique public key that exists in both arrays, throws error if the common
+* pubkey does not equal to one.
+*
+* @param arr1 - The first pubkeys array.
+* @param arr2 - The second pubkeys array.
+* @returns The only common pubkey in both arrays.
+*/
+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];
+}
+/**
+* Constructs the message that the passkey signature is produced over as authenticatorData || sha256(clientDataJSON).
+*/
+function messageFromAssertionResponse(response) {
+	const authenticatorData = new Uint8Array(response.authenticatorData);
+	const clientDataJSONDigest = sha256(new Uint8Array(response.clientDataJSON));
+	return new Uint8Array([...authenticatorData, ...clientDataJSONDigest]);
+}
+
+//#endregion
+export { BrowserPasskeyProvider, PasskeyKeypair, findCommonPublicKey };
+//# sourceMappingURL=keypair.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.mjs","names":["#name","#options","secp256r1"],"sources":["../../../src/keypairs/passkey/keypair.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { toBase64 } from '@haneullabs/bcs';\nimport { p256 as secp256r1 } from '@noble/curves/nist.js';\nimport { blake2b } from '@noble/hashes/blake2.js';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { randomBytes } from '@noble/hashes/utils.js';\n\nimport { PasskeyAuthenticator } from '../../bcs/bcs.js';\nimport type { IntentScope, SignatureWithBytes } from '../../cryptography/index.js';\nimport { messageWithIntent, SIGNATURE_SCHEME_TO_FLAG, Signer } from '../../cryptography/index.js';\nimport type { PublicKey } from '../../cryptography/publickey.js';\nimport type { SignatureScheme } from '../../cryptography/signature-scheme.js';\nimport {\n\tparseDerSPKI,\n\tPASSKEY_PUBLIC_KEY_SIZE,\n\tPASSKEY_SIGNATURE_SIZE,\n\tPasskeyPublicKey,\n} from './publickey.js';\nimport type { AuthenticationCredential, RegistrationCredential } from './types.js';\n\ntype DeepPartialConfigKeys = 'rp' | 'user' | 'authenticatorSelection';\n\ntype DeepPartial<T> = T extends object\n\t? {\n\t\t\t[P in keyof T]?: DeepPartial<T[P]>;\n\t\t}\n\t: T;\n\nexport type BrowserPasswordProviderOptions = Pick<\n\tDeepPartial<PublicKeyCredentialCreationOptions>,\n\tDeepPartialConfigKeys\n> &\n\tOmit<\n\t\tPartial<PublicKeyCredentialCreationOptions>,\n\t\tDeepPartialConfigKeys | 'pubKeyCredParams' | 'challenge'\n\t>;\n\nexport interface PasskeyProvider {\n\tcreate(): Promise<RegistrationCredential>;\n\tget(challenge: Uint8Array): Promise<AuthenticationCredential>;\n}\n\n// Default browser implementation\nexport class BrowserPasskeyProvider implements PasskeyProvider {\n\t#name: string;\n\t#options: BrowserPasswordProviderOptions;\n\n\tconstructor(name: string, options: BrowserPasswordProviderOptions) {\n\t\tthis.#name = name;\n\t\tthis.#options = options;\n\t}\n\n\tasync create(): Promise<RegistrationCredential> {\n\t\treturn (await navigator.credentials.create({\n\t\t\tpublicKey: {\n\t\t\t\ttimeout: this.#options.timeout ?? 60000,\n\t\t\t\t...this.#options,\n\t\t\t\trp: {\n\t\t\t\t\tname: this.#name,\n\t\t\t\t\t...this.#options.rp,\n\t\t\t\t},\n\t\t\t\tuser: {\n\t\t\t\t\tname: this.#name,\n\t\t\t\t\tdisplayName: this.#name,\n\t\t\t\t\t...this.#options.user,\n\t\t\t\t\tid: randomBytes(10) as BufferSource,\n\t\t\t\t},\n\t\t\t\tchallenge: new TextEncoder().encode('Create passkey wallet on Haneul'),\n\t\t\t\tpubKeyCredParams: [{ alg: -7, type: 'public-key' }],\n\t\t\t\tauthenticatorSelection: {\n\t\t\t\t\tauthenticatorAttachment: 'cross-platform',\n\t\t\t\t\tresidentKey: 'required',\n\t\t\t\t\trequireResidentKey: true,\n\t\t\t\t\tuserVerification: 'required',\n\t\t\t\t\t...this.#options.authenticatorSelection,\n\t\t\t\t},\n\t\t\t},\n\t\t})) as RegistrationCredential;\n\t}\n\n\tasync get(challenge: Uint8Array): Promise<AuthenticationCredential> {\n\t\treturn (await navigator.credentials.get({\n\t\t\tpublicKey: {\n\t\t\t\tchallenge: challenge as BufferSource,\n\t\t\t\tuserVerification: this.#options.authenticatorSelection?.userVerification || 'required',\n\t\t\t\ttimeout: this.#options.timeout ?? 60000,\n\t\t\t},\n\t\t})) as AuthenticationCredential;\n\t}\n}\n\n/**\n * @experimental\n * A passkey signer used for signing transactions. This is a client side implementation for [SIP-9](https://github.co./haneul-foundation/sips/blob/main/sips/sip-9.md).\n */\nexport class PasskeyKeypair extends Signer {\n\tprivate publicKey: Uint8Array;\n\tprivate provider: PasskeyProvider;\n\n\t/**\n\t * Get the key scheme of passkey,\n\t */\n\tgetKeyScheme(): SignatureScheme {\n\t\treturn 'Passkey';\n\t}\n\n\t/**\n\t * Creates an instance of Passkey signer. If no passkey wallet had created before,\n\t * use `getPasskeyInstance`. For example:\n\t * ```\n\t * let provider = new BrowserPasskeyProvider('Haneul Passkey Example',{\n\t * \t  rpName: 'Haneul Passkey Example',\n\t * \t  rpId: window.location.hostname,\n\t * } as BrowserPasswordProviderOptions);\n\t * const signer = await PasskeyKeypair.getPasskeyInstance(provider);\n\t * ```\n\t *\n\t * If there are existing passkey wallet, use `signAndRecover` to identify the correct\n\t * public key and then initialize the instance. See usage in `signAndRecover`.\n\t */\n\tconstructor(publicKey: Uint8Array, provider: PasskeyProvider) {\n\t\tsuper();\n\t\tthis.publicKey = publicKey;\n\t\tthis.provider = provider;\n\t}\n\n\t/**\n\t * Creates an instance of Passkey signer invoking the passkey from navigator.\n\t * Note that this will invoke the passkey device to create a fresh credential.\n\t * Should only be called if passkey wallet is created for the first time.\n\t *\n\t * @param provider - the passkey provider.\n\t * @returns the passkey instance.\n\t */\n\tstatic async getPasskeyInstance(provider: PasskeyProvider): Promise<PasskeyKeypair> {\n\t\t// create a passkey secp256r1 with the provider.\n\t\tconst credential = await provider.create();\n\n\t\tif (!credential.response.getPublicKey()) {\n\t\t\tthrow new Error('Invalid credential create response');\n\t\t} else {\n\t\t\tconst derSPKI = credential.response.getPublicKey()!;\n\t\t\tconst pubkeyUncompressed = parseDerSPKI(new Uint8Array(derSPKI));\n\t\t\tconst pubkey = secp256r1.Point.fromBytes(pubkeyUncompressed);\n\t\t\tconst pubkeyCompressed = pubkey.toBytes(true);\n\t\t\treturn new PasskeyKeypair(pubkeyCompressed, provider);\n\t\t}\n\t}\n\n\t/**\n\t * Return the public key for this passkey.\n\t */\n\tgetPublicKey(): PublicKey {\n\t\treturn new PasskeyPublicKey(this.publicKey);\n\t}\n\n\t/**\n\t * Return the signature for the provided data (i.e. blake2b(intent_message)).\n\t * This is sent to passkey as the challenge field.\n\t */\n\tasync sign(data: Uint8Array) {\n\t\t// asks the passkey to sign over challenge as the data.\n\t\tconst credential = await this.provider.get(data);\n\n\t\t// parse authenticatorData (as bytes), clientDataJSON (decoded as string).\n\t\tconst authenticatorData = new Uint8Array(credential.response.authenticatorData);\n\t\tconst clientDataJSON = new Uint8Array(credential.response.clientDataJSON); // response.clientDataJSON is already UTF-8 encoded JSON\n\t\tconst decoder = new TextDecoder();\n\t\tconst clientDataJSONString: string = decoder.decode(clientDataJSON);\n\n\t\tconst sig = secp256r1.Signature.fromBytes(new Uint8Array(credential.response.signature), 'der');\n\t\tconst normalizedSig = sig.hasHighS()\n\t\t\t? new secp256r1.Signature(sig.r, secp256r1.Point.Fn.neg(sig.s))\n\t\t\t: sig;\n\n\t\tconst normalized = normalizedSig.toBytes('compact');\n\n\t\tif (\n\t\t\tnormalized.length !== PASSKEY_SIGNATURE_SIZE ||\n\t\t\tthis.publicKey.length !== PASSKEY_PUBLIC_KEY_SIZE\n\t\t) {\n\t\t\tthrow new Error('Invalid signature or public key length');\n\t\t}\n\n\t\t// construct userSignature as flag || sig || pubkey for the secp256r1 signature.\n\t\tconst arr = new Uint8Array(1 + normalized.length + this.publicKey.length);\n\t\tarr.set([SIGNATURE_SCHEME_TO_FLAG['Secp256r1']]);\n\t\tarr.set(normalized, 1);\n\t\tarr.set(this.publicKey, 1 + normalized.length);\n\n\t\t// serialize all fields into a passkey signature according to https://github.co./haneul-foundation/sips/blob/main/sips/sip-9.md#signature-encoding\n\t\treturn PasskeyAuthenticator.serialize({\n\t\t\tauthenticatorData: authenticatorData,\n\t\t\tclientDataJson: clientDataJSONString,\n\t\t\tuserSignature: arr,\n\t\t}).toBytes();\n\t}\n\n\t/**\n\t * This overrides the base class implementation that accepts the raw bytes and signs its\n\t * digest of the intent message, then serialize it with the passkey flag.\n\t */\n\tasync signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes> {\n\t\t// prepend it into an intent message and computes the digest.\n\t\tconst intentMessage = messageWithIntent(intent, bytes);\n\t\tconst digest = blake2b(intentMessage, { dkLen: 32 });\n\n\t\t// sign the digest.\n\t\tconst signature = await this.sign(digest);\n\n\t\t// prepend with the passkey flag.\n\t\tconst serializedSignature = new Uint8Array(1 + signature.length);\n\t\tserializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[this.getKeyScheme()]]);\n\t\tserializedSignature.set(signature, 1);\n\t\treturn {\n\t\t\tsignature: toBase64(serializedSignature),\n\t\t\tbytes: toBase64(bytes),\n\t\t};\n\t}\n\n\t/**\n\t * Given a message, asks the passkey device to sign it and return all (up to 4) possible public keys.\n\t * See: https://bitcoin.stackexchange.com/questions/81232/how-is-public-key-extracted-from-message-digital-signature-address\n\t *\n\t * This is useful if the user previously created passkey wallet with the origin, but the wallet session\n\t * does not have the public key / address. By calling this method twice with two different messages, the\n\t * wallet can compare the returned public keys and uniquely identify the previously created passkey wallet\n\t * using `findCommonPublicKey`.\n\t *\n\t * Alternatively, one call can be made and all possible public keys should be checked onchain to see if\n\t * there is any assets.\n\t *\n\t * Once the correct public key is identified, a passkey instance can then be initialized with this public key.\n\t *\n\t * Example usage to recover wallet with two signing calls:\n\t * ```\n\t * let provider = new BrowserPasskeyProvider('Haneul Passkey Example',{\n\t *     rpName: 'Haneul Passkey Example',\n\t * \t   rpId: window.location.hostname,\n\t * } as BrowserPasswordProviderOptions);\n\t * const testMessage = new TextEncoder().encode('Hello world!');\n\t * const possiblePks = await PasskeyKeypair.signAndRecover(provider, testMessage);\n\t * const testMessage2 = new TextEncoder().encode('Hello world 2!');\n\t * const possiblePks2 = await PasskeyKeypair.signAndRecover(provider, testMessage2);\n\t * const commonPk = findCommonPublicKey(possiblePks, possiblePks2);\n\t * const signer = new PasskeyKeypair(provider, commonPk.toRawBytes());\n\t * ```\n\t *\n\t * @param provider - the passkey provider.\n\t * @param message - the message to sign.\n\t * @returns all possible public keys.\n\t */\n\tstatic async signAndRecover(\n\t\tprovider: PasskeyProvider,\n\t\tmessage: Uint8Array,\n\t): Promise<PublicKey[]> {\n\t\tconst credential = await provider.get(message);\n\t\tconst fullMessage = messageFromAssertionResponse(credential.response);\n\t\tconst sig = secp256r1.Signature.fromBytes(new Uint8Array(credential.response.signature), 'der');\n\n\t\tconst res = [];\n\t\tconst msgHash = sha256(fullMessage);\n\t\tfor (let i = 0; i < 4; i++) {\n\t\t\tconst s = sig.addRecoveryBit(i);\n\t\t\ttry {\n\t\t\t\tconst pubkey = s.recoverPublicKey(msgHash);\n\t\t\t\tconst pk = new PasskeyPublicKey(pubkey.toBytes(true));\n\t\t\t\tres.push(pk);\n\t\t\t} catch {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\treturn res;\n\t}\n}\n\n/**\n * Finds the unique public key that exists in both arrays, throws error if the common\n * pubkey does not equal to one.\n *\n * @param arr1 - The first pubkeys array.\n * @param arr2 - The second pubkeys array.\n * @returns The only common pubkey in both arrays.\n */\nexport function findCommonPublicKey(arr1: PublicKey[], arr2: PublicKey[]): PublicKey {\n\tconst matchingPubkeys: PublicKey[] = [];\n\tfor (const pubkey1 of arr1) {\n\t\tfor (const pubkey2 of arr2) {\n\t\t\tif (pubkey1.equals(pubkey2)) {\n\t\t\t\tmatchingPubkeys.push(pubkey1);\n\t\t\t}\n\t\t}\n\t}\n\tif (matchingPubkeys.length !== 1) {\n\t\tthrow new Error('No unique public key found');\n\t}\n\treturn matchingPubkeys[0];\n}\n\n/**\n * Constructs the message that the passkey signature is produced over as authenticatorData || sha256(clientDataJSON).\n */\nfunction messageFromAssertionResponse(response: AuthenticatorAssertionResponse): Uint8Array {\n\tconst authenticatorData = new Uint8Array(response.authenticatorData);\n\tconst clientDataJSON = new Uint8Array(response.clientDataJSON);\n\tconst clientDataJSONDigest = sha256(clientDataJSON);\n\treturn new Uint8Array([...authenticatorData, ...clientDataJSONDigest]);\n}\n"],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.d.mts","names":[],"sources":["../../../src/keypairs/passkey/publickey.ts"],"sourcesContent":[],"mappings":";;;;;;;cAiEa,gBAAA,SAAyB,SAAA;;;;;;;qBAQlB;;;;oBAqBQ;;;;gBAOb,WAAW;;;;;;;;kBAcH,uBAAuB,sBAAsB"}

package/dist/keypairs/passkey/publickey.mjs

@@ -0,0 +1,142 @@
+import { PasskeyAuthenticator } from "../../bcs/bcs.mjs";
+import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.mjs";
+import { PublicKey, bytesEqual } from "../../cryptography/publickey.mjs";
+import { fromBase64, toBase64 } from "@haneullabs/bcs";
+import { p256 } from "@noble/curves/nist.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+
+//#region src/keypairs/passkey/publickey.ts
+const PASSKEY_PUBLIC_KEY_SIZE = 33;
+const PASSKEY_UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;
+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)
+*/
+const SECP256R1_SPKI_HEADER = new Uint8Array([
+	48,
+	89,
+	48,
+	19,
+	6,
+	7,
+	42,
+	134,
+	72,
+	206,
+	61,
+	2,
+	1,
+	6,
+	8,
+	42,
+	134,
+	72,
+	206,
+	61,
+	3,
+	1,
+	7,
+	3,
+	66,
+	0
+]);
+/**
+* A passkey public key
+*/
+var PasskeyPublicKey = class extends PublicKey {
+	static {
+		this.SIZE = PASSKEY_PUBLIC_KEY_SIZE;
+	}
+	/**
+	* Create a new PasskeyPublicKey object
+	* @param value passkey 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 !== 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 Haneul address associated with this Secp256r1 public key
+	*/
+	flag() {
+		return 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;
+		if (!bytesEqual(message, fromBase64(clientDataJSON.challenge.replace(/-/g, "+").replace(/_/g, "/")))) return false;
+		const pk = parsed.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE);
+		if (!bytesEqual(this.toRawBytes(), pk)) return false;
+		const payload = new Uint8Array([...parsed.authenticatorData, ...sha256(new TextEncoder().encode(parsed.clientDataJson))]);
+		const sig = parsed.userSignature.slice(1, PASSKEY_SIGNATURE_SIZE + 1);
+		return p256.verify(sig, payload, pk);
+	}
+};
+/**
+* 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`)
+*/
+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);
+}
+/**
+* Parse signature from bytes or base64 string into the following fields.
+*/
+function parseSerializedPasskeySignature(signature) {
+	const bytes = typeof signature === "string" ? fromBase64(signature) : signature;
+	if (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.Passkey) throw new Error("Invalid signature scheme");
+	const dec = PasskeyAuthenticator.parse(bytes.slice(1));
+	return {
+		signatureScheme: "Passkey",
+		serializedSignature: 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))
+	};
+}
+
+//#endregion
+export { PASSKEY_PUBLIC_KEY_SIZE, PASSKEY_SIGNATURE_SIZE, PasskeyPublicKey, parseDerSPKI, parseSerializedPasskeySignature };
+//# sourceMappingURL=publickey.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.mjs","names":["secp256r1"],"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 { p256 as secp256r1 } from '@noble/curves/nist.js';\nimport { sha256 } from '@noble/hashes/sha2.js';\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([\n\t\t\t...parsed.authenticatorData,\n\t\t\t...sha256(new TextEncoder().encode(parsed.clientDataJson)),\n\t\t]);\n\t\tconst sig = parsed.userSignature.slice(1, PASSKEY_SIGNATURE_SIZE + 1);\n\t\treturn secp256r1.verify(sig, 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":";;;;;;;;AAYA,MAAa,0BAA0B;AACvC,MAAa,uCAAuC;AACpD,MAAa,yBAAyB;;;;;;;;;;;;;;;;;;;AAmBtC,MAAa,wBAAwB,IAAI,WAAW;CACnD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAU;;;;AAKX,IAAa,mBAAb,cAAsC,UAAU;;cACjC;;;;;;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,wBACxB,OAAM,IAAI,MACT,sCAAsC,wBAAwB,cAAc,KAAK,KAAK,SACtF;;;;;CAOH,AAAS,OAAO,WAAsC;AACrD,SAAO,MAAM,OAAO,UAAU;;;;;CAM/B,aAAsC;AACrC,SAAO,KAAK;;;;;CAMb,OAAe;AACd,SAAO,yBAAyB;;;;;CAMjC,MAAM,OAAO,SAAqB,WAAkD;EACnF,MAAM,SAAS,gCAAgC,UAAU;EACzD,MAAM,iBAAiB,KAAK,MAAM,OAAO,eAAe;AAExD,MAAI,eAAe,SAAS,eAC3B,QAAO;AAOR,MAAI,CAAC,WAAW,SAHQ,WACvB,eAAe,UAAU,QAAQ,MAAM,IAAI,CAAC,QAAQ,MAAM,IAAI,CAC9D,CACwC,CACxC,QAAO;EAGR,MAAM,KAAK,OAAO,cAAc,MAAM,IAAI,uBAAuB;AACjE,MAAI,CAAC,WAAW,KAAK,YAAY,EAAE,GAAG,CACrC,QAAO;EAGR,MAAM,UAAU,IAAI,WAAW,CAC9B,GAAG,OAAO,mBACV,GAAG,OAAO,IAAI,aAAa,CAAC,OAAO,OAAO,eAAe,CAAC,CAC1D,CAAC;EACF,MAAM,MAAM,OAAO,cAAc,MAAM,GAAG,yBAAyB,EAAE;AACrE,SAAOA,KAAU,OAAO,KAAK,SAAS,GAAG;;;;;;;;;;AAW3C,SAAgB,aAAa,UAAkC;AAE9D,KAAI,SAAS,WAAW,sBAAsB,SAAS,qCACtD,OAAM,IAAI,MAAM,qBAAqB;AAEtC,MAAK,IAAI,IAAI,GAAG,IAAI,sBAAsB,QAAQ,IACjD,KAAI,SAAS,OAAO,sBAAsB,GACzC,OAAM,IAAI,MAAM,sBAAsB;AAIxC,KAAI,SAAS,sBAAsB,YAAY,EAC9C,OAAM,IAAI,MAAM,uBAAuB;AAIxC,QAAO,SAAS,MAAM,sBAAsB,OAAO;;;;;AAMpD,SAAgB,gCAAgC,WAAgC;CAC/E,MAAM,QAAQ,OAAO,cAAc,WAAW,WAAW,UAAU,GAAG;AAEtE,KAAI,MAAM,OAAO,yBAAyB,QACzC,OAAM,IAAI,MAAM,2BAA2B;CAE5C,MAAM,MAAM,qBAAqB,MAAM,MAAM,MAAM,EAAE,CAAC;AACtD,QAAO;EACN,iBAAiB;EACjB,qBAAqB,SAAS,MAAM;EACpC,WAAW;EACX,mBAAmB,IAAI;EACvB,gBAAgB,IAAI;EACpB,eAAe,IAAI,WAAW,IAAI,cAAc;EAChD,WAAW,IAAI,WAAW,IAAI,cAAc,MAAM,IAAI,uBAAuB,CAAC;EAC9E"}

package/dist/keypairs/passkey/types.d.mts

@@ -0,0 +1,16 @@
+//#region src/keypairs/passkey/types.d.ts
+/**
+ * The value returned from navigator.credentials.get()
+ */
+interface AuthenticationCredential extends PublicKeyCredential {
+  response: AuthenticatorAssertionResponse;
+}
+/**
+ * The value returned from navigator.credentials.create()
+ */
+interface RegistrationCredential extends PublicKeyCredential {
+  response: AuthenticatorAttestationResponse;
+}
+//#endregion
+export { AuthenticationCredential, RegistrationCredential };
+//# sourceMappingURL=types.d.mts.map

package/dist/keypairs/passkey/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/keypairs/passkey/types.ts"],"sourcesContent":[],"mappings":";;AAMA;AAOA;UAPiB,wBAAA,SAAiC;YACvC;;;;;UAMM,sBAAA,SAA+B;YACrC"}

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

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

package/dist/keypairs/secp256k1/index.mjs

@@ -0,0 +1,4 @@
+import { Secp256k1PublicKey } from "./publickey.mjs";
+import { DEFAULT_SECP256K1_DERIVATION_PATH, Secp256k1Keypair } from "./keypair.mjs";
+
+export { DEFAULT_SECP256K1_DERIVATION_PATH, Secp256k1Keypair, Secp256k1PublicKey };

package/dist/keypairs/secp256k1/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/secp256k1/keypair.d.ts
+declare const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
+/**
+ * Secp256k1 Keypair data
+ */
+interface Secp256k1KeypairData {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+}
+/**
+ * An Secp256k1 Keypair used for signing transactions.
+ */
+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;
+}
+//#endregion
+export { DEFAULT_SECP256K1_DERIVATION_PATH, Secp256k1Keypair, Secp256k1KeypairData };
+//# sourceMappingURL=keypair.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.d.mts","names":[],"sources":["../../../src/keypairs/secp256k1/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;EAaC;;;;;;EAtG2B,WAAA,CAAA,OAAA,CAAA,EAStB,oBATsB;;;;kBAwB5B;;;;qBAOG;;;;;;;;;;;;;kCAkBP;;MAET;;;;;;wBA8BmB,aAAa;;;;kBAQnB;;;;;;;;aAaC,aAAU,QAAA,WAAA;;;;;;;;0DAa6B"}