@haneullabs/haneul 0.1.0 → 2.5.0

package/dist/jsonRpc/types/params.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.mts","names":[],"sources":["../../../src/jsonRpc/types/params.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/keypairs/ed25519/ed25519-hd-key.mjs

@@ -0,0 +1,45 @@
+import { fromHex } from "@haneullabs/bcs";
+import { sha512 } from "@noble/hashes/sha2.js";
+import { hmac } from "@noble/hashes/hmac.js";
+
+//#region src/keypairs/ed25519/ed25519-hd-key.ts
+const ED25519_CURVE = "ed25519 seed";
+const HARDENED_OFFSET = 2147483648;
+const pathRegex = /* @__PURE__ */ new RegExp("^m(\\/[0-9]+')+$");
+const replaceDerive = (val) => val.replace("'", "");
+const getMasterKeyFromSeed = (seed) => {
+	const I = hmac.create(sha512, new TextEncoder().encode(ED25519_CURVE)).update(fromHex(seed)).digest();
+	return {
+		key: I.slice(0, 32),
+		chainCode: I.slice(32)
+	};
+};
+const CKDPriv = ({ key, chainCode }, index) => {
+	const indexBuffer = /* @__PURE__ */ new ArrayBuffer(4);
+	new DataView(indexBuffer).setUint32(0, index);
+	const data = new Uint8Array(1 + key.length + indexBuffer.byteLength);
+	data.set(new Uint8Array(1).fill(0));
+	data.set(key, 1);
+	data.set(new Uint8Array(indexBuffer, 0, indexBuffer.byteLength), key.length + 1);
+	const I = hmac.create(sha512, chainCode).update(data).digest();
+	return {
+		key: I.slice(0, 32),
+		chainCode: I.slice(32)
+	};
+};
+const isValidPath = (path) => {
+	if (!pathRegex.test(path)) return false;
+	return !path.split("/").slice(1).map(replaceDerive).some(isNaN);
+};
+const derivePath = (path, seed, offset = HARDENED_OFFSET) => {
+	if (!isValidPath(path)) throw new Error("Invalid derivation path");
+	const { key, chainCode } = getMasterKeyFromSeed(seed);
+	return path.split("/").slice(1).map(replaceDerive).map((el) => parseInt(el, 10)).reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
+		key,
+		chainCode
+	});
+};
+
+//#endregion
+export { derivePath };
+//# sourceMappingURL=ed25519-hd-key.mjs.map

package/dist/keypairs/ed25519/ed25519-hd-key.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519-hd-key.mjs","names":[],"sources":["../../../src/keypairs/ed25519/ed25519-hd-key.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n// This is adapted from https://github.com/alepop/ed25519-hd-key replacing create-hmac\n// with @noble/hashes to be browser compatible.\n\nimport { fromHex } from '@haneullabs/bcs';\nimport { hmac } from '@noble/hashes/hmac.js';\nimport { sha512 } from '@noble/hashes/sha2.js';\n\ntype Hex = string;\ntype Path = string;\n\ntype Keys = {\n\tkey: Uint8Array;\n\tchainCode: Uint8Array;\n};\n\nconst ED25519_CURVE = 'ed25519 seed';\nconst HARDENED_OFFSET = 0x80000000;\n\nconst pathRegex = new RegExp(\"^m(\\\\/[0-9]+')+$\");\n\nconst replaceDerive = (val: string): string => val.replace(\"'\", '');\n\nconst getMasterKeyFromSeed = (seed: Hex): Keys => {\n\tconst h = hmac.create(sha512, new TextEncoder().encode(ED25519_CURVE));\n\tconst I = h.update(fromHex(seed)).digest();\n\tconst IL = I.slice(0, 32);\n\tconst IR = I.slice(32);\n\treturn {\n\t\tkey: IL,\n\t\tchainCode: IR,\n\t};\n};\n\nconst CKDPriv = ({ key, chainCode }: Keys, index: number): Keys => {\n\tconst indexBuffer = new ArrayBuffer(4);\n\tconst cv = new DataView(indexBuffer);\n\tcv.setUint32(0, index);\n\n\tconst data = new Uint8Array(1 + key.length + indexBuffer.byteLength);\n\tdata.set(new Uint8Array(1).fill(0));\n\tdata.set(key, 1);\n\tdata.set(new Uint8Array(indexBuffer, 0, indexBuffer.byteLength), key.length + 1);\n\n\tconst I = hmac.create(sha512, chainCode).update(data).digest();\n\tconst IL = I.slice(0, 32);\n\tconst IR = I.slice(32);\n\treturn {\n\t\tkey: IL,\n\t\tchainCode: IR,\n\t};\n};\n\nconst isValidPath = (path: string): boolean => {\n\tif (!pathRegex.test(path)) {\n\t\treturn false;\n\t}\n\treturn !path\n\t\t.split('/')\n\t\t.slice(1)\n\t\t.map(replaceDerive)\n\t\t.some(isNaN as any /* ts T_T*/);\n};\n\nexport const derivePath = (path: Path, seed: Hex, offset = HARDENED_OFFSET): Keys => {\n\tif (!isValidPath(path)) {\n\t\tthrow new Error('Invalid derivation path');\n\t}\n\n\tconst { key, chainCode } = getMasterKeyFromSeed(seed);\n\tconst segments = path\n\t\t.split('/')\n\t\t.slice(1)\n\t\t.map(replaceDerive)\n\t\t.map((el) => parseInt(el, 10));\n\n\treturn segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {\n\t\tkey,\n\t\tchainCode,\n\t});\n};\n"],"mappings":";;;;;AAkBA,MAAM,gBAAgB;AACtB,MAAM,kBAAkB;AAExB,MAAM,4BAAY,IAAI,OAAO,mBAAmB;AAEhD,MAAM,iBAAiB,QAAwB,IAAI,QAAQ,KAAK,GAAG;AAEnE,MAAM,wBAAwB,SAAoB;CAEjD,MAAM,IADI,KAAK,OAAO,QAAQ,IAAI,aAAa,CAAC,OAAO,cAAc,CAAC,CAC1D,OAAO,QAAQ,KAAK,CAAC,CAAC,QAAQ;AAG1C,QAAO;EACN,KAHU,EAAE,MAAM,GAAG,GAAG;EAIxB,WAHU,EAAE,MAAM,GAAG;EAIrB;;AAGF,MAAM,WAAW,EAAE,KAAK,aAAmB,UAAwB;CAClE,MAAM,8BAAc,IAAI,YAAY,EAAE;AAEtC,CADW,IAAI,SAAS,YAAY,CACjC,UAAU,GAAG,MAAM;CAEtB,MAAM,OAAO,IAAI,WAAW,IAAI,IAAI,SAAS,YAAY,WAAW;AACpE,MAAK,IAAI,IAAI,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC;AACnC,MAAK,IAAI,KAAK,EAAE;AAChB,MAAK,IAAI,IAAI,WAAW,aAAa,GAAG,YAAY,WAAW,EAAE,IAAI,SAAS,EAAE;CAEhF,MAAM,IAAI,KAAK,OAAO,QAAQ,UAAU,CAAC,OAAO,KAAK,CAAC,QAAQ;AAG9D,QAAO;EACN,KAHU,EAAE,MAAM,GAAG,GAAG;EAIxB,WAHU,EAAE,MAAM,GAAG;EAIrB;;AAGF,MAAM,eAAe,SAA0B;AAC9C,KAAI,CAAC,UAAU,KAAK,KAAK,CACxB,QAAO;AAER,QAAO,CAAC,KACN,MAAM,IAAI,CACV,MAAM,EAAE,CACR,IAAI,cAAc,CAClB,KAAK,MAAyB;;AAGjC,MAAa,cAAc,MAAY,MAAW,SAAS,oBAA0B;AACpF,KAAI,CAAC,YAAY,KAAK,CACrB,OAAM,IAAI,MAAM,0BAA0B;CAG3C,MAAM,EAAE,KAAK,cAAc,qBAAqB,KAAK;AAOrD,QANiB,KACf,MAAM,IAAI,CACV,MAAM,EAAE,CACR,IAAI,cAAc,CAClB,KAAK,OAAO,SAAS,IAAI,GAAG,CAAC,CAEf,QAAQ,YAAY,YAAY,QAAQ,YAAY,UAAU,OAAO,EAAE;EACtF;EACA;EACA,CAAC"}

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

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

package/dist/keypairs/ed25519/index.mjs

@@ -0,0 +1,4 @@
+import { Ed25519PublicKey } from "./publickey.mjs";
+import { DEFAULT_ED25519_DERIVATION_PATH, Ed25519Keypair } from "./keypair.mjs";
+
+export { DEFAULT_ED25519_DERIVATION_PATH, Ed25519Keypair, Ed25519PublicKey };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.d.mts","names":[],"sources":["../../../src/keypairs/ed25519/keypair.ts"],"sourcesContent":[],"mappings":";;;;;cAgBa,+BAAA;;AAAb;AAOA;AAQA;;AA4BiB,UApCA,kBAAA,CAoCA;EAOG,SAAA,EA1CR,UA0CQ;EAmBP,SAAA,EA5DD,UA4DC;;;;;AAuDe,cA7Gf,cAAA,SAAuB,OAAA,CA6GR;EAAA,QAAA,OAAA;EAW6B;;;;;;wBA/GlC;;;;kBAmBN;;;;qBAOG;;;;;;;;;;;kCAmBP;;MAET;;;;kBAoCa;;;;;;;;aAiBC,aAAU,QAAA,WAAA;;;;;;;;0DAW6B;;;;;;;gEAkBM"}

package/dist/keypairs/ed25519/keypair.mjs

@@ -0,0 +1,125 @@
+import { isValidHardenedPath, mnemonicToSeedHex } from "../../cryptography/mnemonics.mjs";
+import { Keypair, PRIVATE_KEY_SIZE, decodeSuiPrivateKey, encodeSuiPrivateKey } from "../../cryptography/keypair.mjs";
+import { derivePath } from "./ed25519-hd-key.mjs";
+import { Ed25519PublicKey } from "./publickey.mjs";
+import { ed25519 } from "@noble/curves/ed25519.js";
+
+//#region src/keypairs/ed25519/keypair.ts
+const DEFAULT_ED25519_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
+/**
+* An Ed25519 Keypair used for signing transactions.
+*/
+var Ed25519Keypair = class Ed25519Keypair extends Keypair {
+	/**
+	* Create a new Ed25519 keypair instance.
+	* Generate random keypair if no {@link Ed25519Keypair} is provided.
+	*
+	* @param keypair Ed25519 keypair
+	*/
+	constructor(keypair) {
+		super();
+		if (keypair) this.keypair = {
+			publicKey: keypair.publicKey,
+			secretKey: keypair.secretKey.slice(0, 32)
+		};
+		else {
+			const privateKey = ed25519.utils.randomSecretKey();
+			this.keypair = {
+				publicKey: ed25519.getPublicKey(privateKey),
+				secretKey: privateKey
+			};
+		}
+	}
+	/**
+	* Get the key scheme of the keypair ED25519
+	*/
+	getKeyScheme() {
+		return "ED25519";
+	}
+	/**
+	* Generate a new random Ed25519 keypair
+	*/
+	static generate() {
+		const secretKey = ed25519.utils.randomSecretKey();
+		return new Ed25519Keypair({
+			publicKey: ed25519.getPublicKey(secretKey),
+			secretKey
+		});
+	}
+	/**
+	* Create a Ed25519 keypair from a raw secret key byte array, also known as seed.
+	* This is NOT the private scalar which is result of hashing and bit clamping of
+	* the raw secret key.
+	*
+	* @throws error if the provided secret key is invalid and validation is not skipped.
+	*
+	* @param secretKey secret key as a byte array or Bech32 secret key string
+	* @param options: skip secret key validation
+	*/
+	static fromSecretKey(secretKey, options) {
+		if (typeof secretKey === "string") {
+			const decoded = decodeSuiPrivateKey(secretKey);
+			if (decoded.scheme !== "ED25519") throw new Error(`Expected a ED25519 keypair, got ${decoded.scheme}`);
+			return this.fromSecretKey(decoded.secretKey, options);
+		}
+		const secretKeyLength = secretKey.length;
+		if (secretKeyLength !== PRIVATE_KEY_SIZE) throw new Error(`Wrong secretKey size. Expected ${PRIVATE_KEY_SIZE} bytes, got ${secretKeyLength}.`);
+		const keypair = {
+			publicKey: ed25519.getPublicKey(secretKey),
+			secretKey
+		};
+		if (!options || !options.skipValidation) {
+			const signData = new TextEncoder().encode("haneul validation");
+			const signature = ed25519.sign(signData, secretKey);
+			if (!ed25519.verify(signature, signData, keypair.publicKey)) throw new Error("provided secretKey is invalid");
+		}
+		return new Ed25519Keypair(keypair);
+	}
+	/**
+	* The public key for this Ed25519 keypair
+	*/
+	getPublicKey() {
+		return new Ed25519PublicKey(this.keypair.publicKey);
+	}
+	/**
+	* The Bech32 secret key string for this Ed25519 keypair
+	*/
+	getSecretKey() {
+		return encodeSuiPrivateKey(this.keypair.secretKey.slice(0, PRIVATE_KEY_SIZE), this.getKeyScheme());
+	}
+	/**
+	* Return the signature for the provided data using Ed25519.
+	*/
+	async sign(data) {
+		return ed25519.sign(data, this.keypair.secretKey);
+	}
+	/**
+	* Derive Ed25519 keypair from mnemonics and path. The mnemonics must be normalized
+	* and validated against the english wordlist.
+	*
+	* If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+	* be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+	*/
+	static deriveKeypair(mnemonics, path) {
+		if (path == null) path = DEFAULT_ED25519_DERIVATION_PATH;
+		if (!isValidHardenedPath(path)) throw new Error("Invalid derivation path");
+		const { key } = derivePath(path, mnemonicToSeedHex(mnemonics));
+		return Ed25519Keypair.fromSecretKey(key);
+	}
+	/**
+	* Derive Ed25519 keypair from mnemonicSeed and path.
+	*
+	* If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+	* be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+	*/
+	static deriveKeypairFromSeed(seedHex, path) {
+		if (path == null) path = DEFAULT_ED25519_DERIVATION_PATH;
+		if (!isValidHardenedPath(path)) throw new Error("Invalid derivation path");
+		const { key } = derivePath(path, seedHex);
+		return Ed25519Keypair.fromSecretKey(key);
+	}
+};
+
+//#endregion
+export { DEFAULT_ED25519_DERIVATION_PATH, Ed25519Keypair };
+//# sourceMappingURL=keypair.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.mjs","names":[],"sources":["../../../src/keypairs/ed25519/keypair.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ed25519 } from '@noble/curves/ed25519.js';\n\nimport {\n\tdecodeSuiPrivateKey,\n\tencodeSuiPrivateKey,\n\tKeypair,\n\tPRIVATE_KEY_SIZE,\n} from '../../cryptography/keypair.js';\nimport { isValidHardenedPath, mnemonicToSeedHex } from '../../cryptography/mnemonics.js';\nimport type { SignatureScheme } from '../../cryptography/signature-scheme.js';\nimport { derivePath } from './ed25519-hd-key.js';\nimport { Ed25519PublicKey } from './publickey.js';\n\nexport const DEFAULT_ED25519_DERIVATION_PATH = \"m/44'/784'/0'/0'/0'\";\n\n/**\n * Ed25519 Keypair data. The publickey is the 32-byte public key and\n * the secretkey is 64-byte, where the first 32 bytes is the secret\n * key and the last 32 bytes is the public key.\n */\nexport interface Ed25519KeypairData {\n\tpublicKey: Uint8Array;\n\tsecretKey: Uint8Array;\n}\n\n/**\n * An Ed25519 Keypair used for signing transactions.\n */\nexport class Ed25519Keypair extends Keypair {\n\tprivate keypair: Ed25519KeypairData;\n\n\t/**\n\t * Create a new Ed25519 keypair instance.\n\t * Generate random keypair if no {@link Ed25519Keypair} is provided.\n\t *\n\t * @param keypair Ed25519 keypair\n\t */\n\tconstructor(keypair?: Ed25519KeypairData) {\n\t\tsuper();\n\t\tif (keypair) {\n\t\t\tthis.keypair = {\n\t\t\t\tpublicKey: keypair.publicKey,\n\t\t\t\tsecretKey: keypair.secretKey.slice(0, 32),\n\t\t\t};\n\t\t} else {\n\t\t\tconst privateKey = ed25519.utils.randomSecretKey();\n\t\t\tthis.keypair = {\n\t\t\t\tpublicKey: ed25519.getPublicKey(privateKey),\n\t\t\t\tsecretKey: privateKey,\n\t\t\t};\n\t\t}\n\t}\n\n\t/**\n\t * Get the key scheme of the keypair ED25519\n\t */\n\tgetKeyScheme(): SignatureScheme {\n\t\treturn 'ED25519';\n\t}\n\n\t/**\n\t * Generate a new random Ed25519 keypair\n\t */\n\tstatic generate(): Ed25519Keypair {\n\t\tconst secretKey = ed25519.utils.randomSecretKey();\n\t\treturn new Ed25519Keypair({\n\t\t\tpublicKey: ed25519.getPublicKey(secretKey),\n\t\t\tsecretKey,\n\t\t});\n\t}\n\n\t/**\n\t * Create a Ed25519 keypair from a raw secret key byte array, also known as seed.\n\t * This is NOT the private scalar which is result of hashing and bit clamping of\n\t * the raw secret key.\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 as a byte array or Bech32 secret key string\n\t * @param options: skip secret key validation\n\t */\n\tstatic fromSecretKey(\n\t\tsecretKey: Uint8Array | string,\n\t\toptions?: { skipValidation?: boolean },\n\t): Ed25519Keypair {\n\t\tif (typeof secretKey === 'string') {\n\t\t\tconst decoded = decodeSuiPrivateKey(secretKey);\n\n\t\t\tif (decoded.scheme !== 'ED25519') {\n\t\t\t\tthrow new Error(`Expected a ED25519 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 secretKeyLength = secretKey.length;\n\t\tif (secretKeyLength !== PRIVATE_KEY_SIZE) {\n\t\t\tthrow new Error(\n\t\t\t\t`Wrong secretKey size. Expected ${PRIVATE_KEY_SIZE} bytes, got ${secretKeyLength}.`,\n\t\t\t);\n\t\t}\n\t\tconst keypair = {\n\t\t\tpublicKey: ed25519.getPublicKey(secretKey),\n\t\t\tsecretKey,\n\t\t};\n\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 signature = ed25519.sign(signData, secretKey);\n\t\t\tif (!ed25519.verify(signature, signData, keypair.publicKey)) {\n\t\t\t\tthrow new Error('provided secretKey is invalid');\n\t\t\t}\n\t\t}\n\t\treturn new Ed25519Keypair(keypair);\n\t}\n\n\t/**\n\t * The public key for this Ed25519 keypair\n\t */\n\tgetPublicKey(): Ed25519PublicKey {\n\t\treturn new Ed25519PublicKey(this.keypair.publicKey);\n\t}\n\n\t/**\n\t * The Bech32 secret key string for this Ed25519 keypair\n\t */\n\tgetSecretKey(): string {\n\t\treturn encodeSuiPrivateKey(\n\t\t\tthis.keypair.secretKey.slice(0, PRIVATE_KEY_SIZE),\n\t\t\tthis.getKeyScheme(),\n\t\t);\n\t}\n\n\t/**\n\t * Return the signature for the provided data using Ed25519.\n\t */\n\tasync sign(data: Uint8Array) {\n\t\treturn ed25519.sign(data, this.keypair.secretKey) as Uint8Array<ArrayBuffer>;\n\t}\n\n\t/**\n\t * Derive Ed25519 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/44'/784'/0'/0'/0', otherwise the path must\n\t * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.\n\t */\n\tstatic deriveKeypair(mnemonics: string, path?: string): Ed25519Keypair {\n\t\tif (path == null) {\n\t\t\tpath = DEFAULT_ED25519_DERIVATION_PATH;\n\t\t}\n\t\tif (!isValidHardenedPath(path)) {\n\t\t\tthrow new Error('Invalid derivation path');\n\t\t}\n\t\tconst { key } = derivePath(path, mnemonicToSeedHex(mnemonics));\n\n\t\treturn Ed25519Keypair.fromSecretKey(key);\n\t}\n\n\t/**\n\t * Derive Ed25519 keypair from mnemonicSeed and path.\n\t *\n\t * If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must\n\t * be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.\n\t */\n\tstatic deriveKeypairFromSeed(seedHex: string, path?: string): Ed25519Keypair {\n\t\tif (path == null) {\n\t\t\tpath = DEFAULT_ED25519_DERIVATION_PATH;\n\t\t}\n\t\tif (!isValidHardenedPath(path)) {\n\t\t\tthrow new Error('Invalid derivation path');\n\t\t}\n\t\tconst { key } = derivePath(path, seedHex);\n\n\t\treturn Ed25519Keypair.fromSecretKey(key);\n\t}\n}\n"],"mappings":";;;;;;;AAgBA,MAAa,kCAAkC;;;;AAe/C,IAAa,iBAAb,MAAa,uBAAuB,QAAQ;;;;;;;CAS3C,YAAY,SAA8B;AACzC,SAAO;AACP,MAAI,QACH,MAAK,UAAU;GACd,WAAW,QAAQ;GACnB,WAAW,QAAQ,UAAU,MAAM,GAAG,GAAG;GACzC;OACK;GACN,MAAM,aAAa,QAAQ,MAAM,iBAAiB;AAClD,QAAK,UAAU;IACd,WAAW,QAAQ,aAAa,WAAW;IAC3C,WAAW;IACX;;;;;;CAOH,eAAgC;AAC/B,SAAO;;;;;CAMR,OAAO,WAA2B;EACjC,MAAM,YAAY,QAAQ,MAAM,iBAAiB;AACjD,SAAO,IAAI,eAAe;GACzB,WAAW,QAAQ,aAAa,UAAU;GAC1C;GACA,CAAC;;;;;;;;;;;;CAaH,OAAO,cACN,WACA,SACiB;AACjB,MAAI,OAAO,cAAc,UAAU;GAClC,MAAM,UAAU,oBAAoB,UAAU;AAE9C,OAAI,QAAQ,WAAW,UACtB,OAAM,IAAI,MAAM,mCAAmC,QAAQ,SAAS;AAGrE,UAAO,KAAK,cAAc,QAAQ,WAAW,QAAQ;;EAGtD,MAAM,kBAAkB,UAAU;AAClC,MAAI,oBAAoB,iBACvB,OAAM,IAAI,MACT,kCAAkC,iBAAiB,cAAc,gBAAgB,GACjF;EAEF,MAAM,UAAU;GACf,WAAW,QAAQ,aAAa,UAAU;GAC1C;GACA;AAED,MAAI,CAAC,WAAW,CAAC,QAAQ,gBAAgB;GAExC,MAAM,WADU,IAAI,aAAa,CACR,OAAO,oBAAoB;GACpD,MAAM,YAAY,QAAQ,KAAK,UAAU,UAAU;AACnD,OAAI,CAAC,QAAQ,OAAO,WAAW,UAAU,QAAQ,UAAU,CAC1D,OAAM,IAAI,MAAM,gCAAgC;;AAGlD,SAAO,IAAI,eAAe,QAAQ;;;;;CAMnC,eAAiC;AAChC,SAAO,IAAI,iBAAiB,KAAK,QAAQ,UAAU;;;;;CAMpD,eAAuB;AACtB,SAAO,oBACN,KAAK,QAAQ,UAAU,MAAM,GAAG,iBAAiB,EACjD,KAAK,cAAc,CACnB;;;;;CAMF,MAAM,KAAK,MAAkB;AAC5B,SAAO,QAAQ,KAAK,MAAM,KAAK,QAAQ,UAAU;;;;;;;;;CAUlD,OAAO,cAAc,WAAmB,MAA+B;AACtE,MAAI,QAAQ,KACX,QAAO;AAER,MAAI,CAAC,oBAAoB,KAAK,CAC7B,OAAM,IAAI,MAAM,0BAA0B;EAE3C,MAAM,EAAE,QAAQ,WAAW,MAAM,kBAAkB,UAAU,CAAC;AAE9D,SAAO,eAAe,cAAc,IAAI;;;;;;;;CASzC,OAAO,sBAAsB,SAAiB,MAA+B;AAC5E,MAAI,QAAQ,KACX,QAAO;AAER,MAAI,CAAC,oBAAoB,KAAK,CAC7B,OAAM,IAAI,MAAM,0BAA0B;EAE3C,MAAM,EAAE,QAAQ,WAAW,MAAM,QAAQ;AAEzC,SAAO,eAAe,cAAc,IAAI"}

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

@@ -0,0 +1,35 @@
+import { PublicKey, PublicKeyInitData } from "../../cryptography/publickey.mjs";
+
+//#region src/keypairs/ed25519/publickey.d.ts
+
+/**
+ * An Ed25519 public key
+ */
+declare class Ed25519PublicKey extends PublicKey {
+  static SIZE: number;
+  private data;
+  /**
+   * Create a new Ed25519PublicKey object
+   * @param value ed25519 public key as buffer or base-64 encoded string
+   */
+  constructor(value: PublicKeyInitData);
+  /**
+   * Checks if two Ed25519 public keys are equal
+   */
+  equals(publicKey: Ed25519PublicKey): boolean;
+  /**
+   * Return the byte array representation of the Ed25519 public key
+   */
+  toRawBytes(): Uint8Array<ArrayBuffer>;
+  /**
+   * Return the Haneul address associated with this Ed25519 public key
+   */
+  flag(): number;
+  /**
+   * Verifies that the signature is valid for for the provided message
+   */
+  verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+}
+//#endregion
+export { Ed25519PublicKey };
+//# sourceMappingURL=publickey.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.d.mts","names":[],"sources":["../../../src/keypairs/ed25519/publickey.ts"],"sourcesContent":[],"mappings":";;;;;AAmBA;;AA6B4B,cA7Bf,gBAAA,SAAyB,SAAA,CA6BV;EAOF,OAAA,IAAA,EAAA,MAAA;EAAX,QAAA,IAAA;EAcQ;;;;EAlDwB,WAAA,CAAA,KAAA,EAQ3B,iBAR2B;;;;oBA6BnB;;;;gBAOb,WAAW;;;;;;;;kBAcH,uBAAuB,sBAAsB"}

package/dist/keypairs/ed25519/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 { ed25519 } from "@noble/curves/ed25519.js";
+
+//#region src/keypairs/ed25519/publickey.ts
+const PUBLIC_KEY_SIZE = 32;
+/**
+* An Ed25519 public key
+*/
+var Ed25519PublicKey = class extends PublicKey {
+	static {
+		this.SIZE = PUBLIC_KEY_SIZE;
+	}
+	/**
+	* Create a new Ed25519PublicKey object
+	* @param value ed25519 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 !== PUBLIC_KEY_SIZE) throw new Error(`Invalid public key input. Expected ${PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
+	}
+	/**
+	* Checks if two Ed25519 public keys are equal
+	*/
+	equals(publicKey) {
+		return super.equals(publicKey);
+	}
+	/**
+	* Return the byte array representation of the Ed25519 public key
+	*/
+	toRawBytes() {
+		return this.data;
+	}
+	/**
+	* Return the Haneul address associated with this Ed25519 public key
+	*/
+	flag() {
+		return SIGNATURE_SCHEME_TO_FLAG["ED25519"];
+	}
+	/**
+	* Verifies that the signature is valid for for the provided message
+	*/
+	async verify(message, signature) {
+		let bytes;
+		if (typeof signature === "string") {
+			const parsed = parseSerializedKeypairSignature(signature);
+			if (parsed.signatureScheme !== "ED25519") 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 ed25519.verify(bytes, message, this.toRawBytes());
+	}
+};
+
+//#endregion
+export { Ed25519PublicKey };
+//# sourceMappingURL=publickey.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.mjs","names":[],"sources":["../../../src/keypairs/ed25519/publickey.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64 } from '@haneullabs/bcs';\nimport { ed25519 } from '@noble/curves/ed25519.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 PUBLIC_KEY_SIZE = 32;\n\n/**\n * An Ed25519 public key\n */\nexport class Ed25519PublicKey extends PublicKey {\n\tstatic SIZE = PUBLIC_KEY_SIZE;\n\tprivate data: Uint8Array<ArrayBuffer>;\n\n\t/**\n\t * Create a new Ed25519PublicKey object\n\t * @param value ed25519 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 !== PUBLIC_KEY_SIZE) {\n\t\t\tthrow new Error(\n\t\t\t\t`Invalid public key input. Expected ${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 Ed25519 public keys are equal\n\t */\n\toverride equals(publicKey: Ed25519PublicKey): boolean {\n\t\treturn super.equals(publicKey);\n\t}\n\n\t/**\n\t * Return the byte array representation of the Ed25519 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 Ed25519 public key\n\t */\n\tflag(): number {\n\t\treturn SIGNATURE_SCHEME_TO_FLAG['ED25519'];\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 !== 'ED25519') {\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 ed25519.verify(bytes, message, this.toRawBytes());\n\t}\n}\n"],"mappings":";;;;;;AAcA,MAAM,kBAAkB;;;;AAKxB,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,gBACxB,OAAM,IAAI,MACT,sCAAsC,gBAAgB,cAAc,KAAK,KAAK,SAC9E;;;;;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,IAAI;AACJ,MAAI,OAAO,cAAc,UAAU;GAClC,MAAM,SAAS,gCAAgC,UAAU;AACzD,OAAI,OAAO,oBAAoB,UAC9B,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,QAAQ,OAAO,OAAO,SAAS,KAAK,YAAY,CAAC"}

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

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

package/dist/keypairs/passkey/index.mjs

@@ -0,0 +1,4 @@
+import { PasskeyPublicKey } from "./publickey.mjs";
+import { BrowserPasskeyProvider, PasskeyKeypair, findCommonPublicKey } from "./keypair.mjs";
+
+export { BrowserPasskeyProvider, PasskeyKeypair, PasskeyPublicKey, findCommonPublicKey };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.d.mts","names":[],"sources":["../../../src/keypairs/passkey/keypair.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAsBK,qBAAA;KAEA,iBAAiB,iCAEP,KAAK,YAAY,EAAE,KANiD,GAQhF,CANE;AAEA,KAMO,8BAAA,GAAiC,IAN7B,CAOf,WAPe,CAOH,kCAPG,CAAA,EAQf,qBARe,CAAA,GAUf,IAVe,CAWd,OAXc,CAWN,kCAXM,CAAA,EAYd,qBAZc,GAAA,kBAAA,GAAA,WAAA,CAAA;AAAM,UAeL,eAAA,CAfK;EAEP,MAAA,EAAA,EAcJ,OAdI,CAcI,sBAdJ,CAAA;EAAiB,GAAA,CAAA,SAAA,EAehB,UAfgB,CAAA,EAeH,OAfG,CAeK,wBAfL,CAAA;;AAAZ,cAmBP,sBAAA,YAAkC,eAnB3B,CAAA;EAEjB,CAAA,OAAA;EAAC,WAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAqBgC,8BArBhC;EAEQ,MAAA,CAAA,CAAA,EAwBK,OAxBL,CAwBa,sBAxBiB,CAAA;EAC7B,GAAA,CAAA,SAAA,EAmDS,UAnDT,CAAA,EAmDsB,OAnDtB,CAmD8B,wBAnD9B,CAAA;;;;;;AAKX,cA6DW,cAAA,SAAuB,MAAA,CA7DlC;EAFD,QAAA,SAAA;EAAI,QAAA,QAAA;EAKY;;;EAED,YAAA,CAAA,CAAA,EA+DC,eA/DD;EAAqB;;;AAIrC;;;;;;;;;AAoDA;;EAyBwB,WAAA,CAAA,SAAA,EAAA,UAAA,EAAA,QAAA,EAAsB,eAAtB;EAAsB;;;;;;;;EAwClB,OAAA,kBAAA,CAAA,QAAA,EA1Be,eA0Bf,CAAA,EA1BiC,OA0BjC,CA1ByC,cA0BzC,CAAA;EA0CC;;;EAAkC,YAAA,CAAA,CAAA,EAlD9C,SAkD8C;EAmDnD;;;;EA9JwB,IAAA,CAAA,IAAA,EAiElB,UAjEkB,CAAA,EAiER,OAjEQ,CAiER,UAjEQ,CAiER,WAjEQ,CAAA,CAAA;EAAM;AA6L1C;;;EAA2E,cAAA,CAAA,KAAA,EAlF9C,UAkF8C,EAAA,MAAA,EAlF1B,WAkF0B,CAAA,EAlFZ,OAkFY,CAlFJ,kBAkFI,CAAA;EAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA/BxE,0BACD,aACP,QAAQ;;;;;;;;;;iBA6BI,mBAAA,OAA0B,mBAAmB,cAAc"}