@haneullabs/haneul 0.1.0 → 2.5.0

package/dist/cryptography/keypair.mjs

@@ -0,0 +1,96 @@
+import { messageWithIntent } from "./intent.mjs";
+import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from "./signature-scheme.mjs";
+import { toSerializedSignature } from "./signature.mjs";
+import { bcs, toBase64 } from "@haneullabs/bcs";
+import { blake2b } from "@noble/hashes/blake2.js";
+import { bech32 } from "@scure/base";
+
+//#region src/cryptography/keypair.ts
+const PRIVATE_KEY_SIZE = 32;
+const LEGACY_PRIVATE_KEY_SIZE = 64;
+const HANEUL_PRIVATE_KEY_PREFIX = "haneulprivkey";
+/**
+* TODO: Document
+*/
+var Signer = class {
+	/**
+	* Sign messages with a specific intent. By combining the message bytes with the intent before hashing and signing,
+	* it ensures that a signed message is tied to a specific purpose and domain separator is provided
+	*/
+	async signWithIntent(bytes, intent) {
+		const digest = blake2b(messageWithIntent(intent, bytes), { dkLen: 32 });
+		return {
+			signature: toSerializedSignature({
+				signature: await this.sign(digest),
+				signatureScheme: this.getKeyScheme(),
+				publicKey: this.getPublicKey()
+			}),
+			bytes: toBase64(bytes)
+		};
+	}
+	/**
+	* Signs provided transaction by calling `signWithIntent()` with a `TransactionData` provided as intent scope
+	*/
+	async signTransaction(bytes) {
+		return this.signWithIntent(bytes, "TransactionData");
+	}
+	/**
+	* Signs provided personal message by calling `signWithIntent()` with a `PersonalMessage` provided as intent scope
+	*/
+	async signPersonalMessage(bytes) {
+		const { signature } = await this.signWithIntent(bcs.byteVector().serialize(bytes).toBytes(), "PersonalMessage");
+		return {
+			bytes: toBase64(bytes),
+			signature
+		};
+	}
+	async signAndExecuteTransaction({ transaction, client }) {
+		transaction.setSenderIfNotSet(this.toHaneulAddress());
+		const bytes = await transaction.build({ client });
+		const { signature } = await this.signTransaction(bytes);
+		return client.core.executeTransaction({
+			transaction: bytes,
+			signatures: [signature],
+			include: {
+				transaction: true,
+				effects: true
+			}
+		});
+	}
+	toHaneulAddress() {
+		return this.getPublicKey().toHaneulAddress();
+	}
+};
+var Keypair = class extends Signer {};
+/**
+* This returns an ParsedKeypair object based by validating the
+* 33-byte Bech32 encoded string starting with `haneulprivkey`, and
+* parse out the signature scheme and the private key in bytes.
+*/
+function decodeSuiPrivateKey(value) {
+	const { prefix, words } = bech32.decode(value);
+	if (prefix !== HANEUL_PRIVATE_KEY_PREFIX) throw new Error("invalid private key prefix");
+	const extendedSecretKey = new Uint8Array(bech32.fromWords(words));
+	const secretKey = extendedSecretKey.slice(1);
+	return {
+		scheme: SIGNATURE_FLAG_TO_SCHEME[extendedSecretKey[0]],
+		secretKey
+	};
+}
+/**
+* This returns a Bech32 encoded string starting with `haneulprivkey`,
+* encoding 33-byte `flag || bytes` for the given the 32-byte private
+* key and its signature scheme.
+*/
+function encodeSuiPrivateKey(bytes, scheme) {
+	if (bytes.length !== PRIVATE_KEY_SIZE) throw new Error("Invalid bytes length");
+	const flag = SIGNATURE_SCHEME_TO_FLAG[scheme];
+	const privKeyBytes = new Uint8Array(bytes.length + 1);
+	privKeyBytes.set([flag]);
+	privKeyBytes.set(bytes, 1);
+	return bech32.encode(HANEUL_PRIVATE_KEY_PREFIX, bech32.toWords(privKeyBytes));
+}
+
+//#endregion
+export { HANEUL_PRIVATE_KEY_PREFIX, Keypair, LEGACY_PRIVATE_KEY_SIZE, PRIVATE_KEY_SIZE, Signer, decodeSuiPrivateKey, encodeSuiPrivateKey };
+//# sourceMappingURL=keypair.mjs.map

package/dist/cryptography/keypair.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.mjs","names":[],"sources":["../../src/cryptography/keypair.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bcs, toBase64 } from '@haneullabs/bcs';\nimport { blake2b } from '@noble/hashes/blake2.js';\nimport { bech32 } from '@scure/base';\n\nimport type { IntentScope } from './intent.js';\nimport { messageWithIntent } from './intent.js';\nimport type { PublicKey } from './publickey.js';\nimport { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from './signature-scheme.js';\nimport type { SignatureScheme } from './signature-scheme.js';\nimport { toSerializedSignature } from './signature.js';\nimport type { Transaction } from '../transactions/Transaction.js';\nimport type { ClientWithCoreApi, HaneulClientTypes } from '../client/index.js';\n\nexport const PRIVATE_KEY_SIZE = 32;\nexport const LEGACY_PRIVATE_KEY_SIZE = 64;\nexport const HANEUL_PRIVATE_KEY_PREFIX = 'haneulprivkey';\n\nexport type ParsedKeypair = {\n\tscheme: SignatureScheme;\n\tsecretKey: Uint8Array;\n};\n\nexport interface SignatureWithBytes {\n\tbytes: string;\n\tsignature: string;\n}\n\nexport interface SignAndExecuteOptions {\n\ttransaction: Transaction;\n\tclient: ClientWithCoreApi;\n}\n\n/**\n * TODO: Document\n */\nexport abstract class Signer {\n\tabstract sign(bytes: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;\n\t/**\n\t * Sign messages with a specific intent. By combining the message bytes with the intent before hashing and signing,\n\t * it ensures that a signed message is tied to a specific purpose and domain separator is provided\n\t */\n\tasync signWithIntent(bytes: Uint8Array, intent: IntentScope): Promise<SignatureWithBytes> {\n\t\tconst intentMessage = messageWithIntent(intent, bytes);\n\t\tconst digest = blake2b(intentMessage, { dkLen: 32 });\n\n\t\tconst signature = toSerializedSignature({\n\t\t\tsignature: await this.sign(digest),\n\t\t\tsignatureScheme: this.getKeyScheme(),\n\t\t\tpublicKey: this.getPublicKey(),\n\t\t});\n\n\t\treturn {\n\t\t\tsignature,\n\t\t\tbytes: toBase64(bytes),\n\t\t};\n\t}\n\t/**\n\t * Signs provided transaction by calling `signWithIntent()` with a `TransactionData` provided as intent scope\n\t */\n\tasync signTransaction(bytes: Uint8Array) {\n\t\treturn this.signWithIntent(bytes, 'TransactionData');\n\t}\n\t/**\n\t * Signs provided personal message by calling `signWithIntent()` with a `PersonalMessage` provided as intent scope\n\t */\n\tasync signPersonalMessage(bytes: Uint8Array) {\n\t\tconst { signature } = await this.signWithIntent(\n\t\t\tbcs.byteVector().serialize(bytes).toBytes(),\n\t\t\t'PersonalMessage',\n\t\t);\n\n\t\treturn {\n\t\t\tbytes: toBase64(bytes),\n\t\t\tsignature,\n\t\t};\n\t}\n\n\tasync signAndExecuteTransaction({\n\t\ttransaction,\n\t\tclient,\n\t}: SignAndExecuteOptions): Promise<\n\t\tHaneulClientTypes.TransactionResult<{ transaction: true; effects: true }>\n\t> {\n\t\ttransaction.setSenderIfNotSet(this.toHaneulAddress());\n\t\tconst bytes = await transaction.build({ client });\n\t\tconst { signature } = await this.signTransaction(bytes);\n\n\t\treturn client.core.executeTransaction({\n\t\t\ttransaction: bytes,\n\t\t\tsignatures: [signature],\n\t\t\tinclude: { transaction: true, effects: true },\n\t\t});\n\t}\n\n\ttoHaneulAddress(): string {\n\t\treturn this.getPublicKey().toHaneulAddress();\n\t}\n\n\t/**\n\t * Get the key scheme of the keypair: Secp256k1 or ED25519\n\t */\n\tabstract getKeyScheme(): SignatureScheme;\n\n\t/**\n\t * The public key for this keypair\n\t */\n\tabstract getPublicKey(): PublicKey;\n}\n\nexport abstract class Keypair extends Signer {\n\t/**\n\t * This returns the Bech32 secret key string for this keypair.\n\t */\n\tabstract getSecretKey(): string;\n}\n\n/**\n * This returns an ParsedKeypair object based by validating the\n * 33-byte Bech32 encoded string starting with `haneulprivkey`, and\n * parse out the signature scheme and the private key in bytes.\n */\nexport function decodeSuiPrivateKey(value: string): ParsedKeypair {\n\tconst { prefix, words } = bech32.decode(value as `${string}1${string}`);\n\tif (prefix !== HANEUL_PRIVATE_KEY_PREFIX) {\n\t\tthrow new Error('invalid private key prefix');\n\t}\n\tconst extendedSecretKey = new Uint8Array(bech32.fromWords(words));\n\tconst secretKey = extendedSecretKey.slice(1);\n\tconst signatureScheme =\n\t\tSIGNATURE_FLAG_TO_SCHEME[extendedSecretKey[0] as keyof typeof SIGNATURE_FLAG_TO_SCHEME];\n\n\treturn {\n\t\tscheme: signatureScheme,\n\t\tsecretKey: secretKey,\n\t};\n}\n\n/**\n * This returns a Bech32 encoded string starting with `haneulprivkey`,\n * encoding 33-byte `flag || bytes` for the given the 32-byte private\n * key and its signature scheme.\n */\nexport function encodeSuiPrivateKey(bytes: Uint8Array, scheme: SignatureScheme): string {\n\tif (bytes.length !== PRIVATE_KEY_SIZE) {\n\t\tthrow new Error('Invalid bytes length');\n\t}\n\tconst flag = SIGNATURE_SCHEME_TO_FLAG[scheme];\n\tconst privKeyBytes = new Uint8Array(bytes.length + 1);\n\tprivKeyBytes.set([flag]);\n\tprivKeyBytes.set(bytes, 1);\n\treturn bech32.encode(HANEUL_PRIVATE_KEY_PREFIX, bech32.toWords(privKeyBytes));\n}\n"],"mappings":";;;;;;;;AAgBA,MAAa,mBAAmB;AAChC,MAAa,0BAA0B;AACvC,MAAa,4BAA4B;;;;AAoBzC,IAAsB,SAAtB,MAA6B;;;;;CAM5B,MAAM,eAAe,OAAmB,QAAkD;EAEzF,MAAM,SAAS,QADO,kBAAkB,QAAQ,MAAM,EAChB,EAAE,OAAO,IAAI,CAAC;AAQpD,SAAO;GACN,WAPiB,sBAAsB;IACvC,WAAW,MAAM,KAAK,KAAK,OAAO;IAClC,iBAAiB,KAAK,cAAc;IACpC,WAAW,KAAK,cAAc;IAC9B,CAAC;GAID,OAAO,SAAS,MAAM;GACtB;;;;;CAKF,MAAM,gBAAgB,OAAmB;AACxC,SAAO,KAAK,eAAe,OAAO,kBAAkB;;;;;CAKrD,MAAM,oBAAoB,OAAmB;EAC5C,MAAM,EAAE,cAAc,MAAM,KAAK,eAChC,IAAI,YAAY,CAAC,UAAU,MAAM,CAAC,SAAS,EAC3C,kBACA;AAED,SAAO;GACN,OAAO,SAAS,MAAM;GACtB;GACA;;CAGF,MAAM,0BAA0B,EAC/B,aACA,UAGC;AACD,cAAY,kBAAkB,KAAK,iBAAiB,CAAC;EACrD,MAAM,QAAQ,MAAM,YAAY,MAAM,EAAE,QAAQ,CAAC;EACjD,MAAM,EAAE,cAAc,MAAM,KAAK,gBAAgB,MAAM;AAEvD,SAAO,OAAO,KAAK,mBAAmB;GACrC,aAAa;GACb,YAAY,CAAC,UAAU;GACvB,SAAS;IAAE,aAAa;IAAM,SAAS;IAAM;GAC7C,CAAC;;CAGH,kBAA0B;AACzB,SAAO,KAAK,cAAc,CAAC,iBAAiB;;;AAc9C,IAAsB,UAAtB,cAAsC,OAAO;;;;;;AAY7C,SAAgB,oBAAoB,OAA8B;CACjE,MAAM,EAAE,QAAQ,UAAU,OAAO,OAAO,MAA+B;AACvE,KAAI,WAAW,0BACd,OAAM,IAAI,MAAM,6BAA6B;CAE9C,MAAM,oBAAoB,IAAI,WAAW,OAAO,UAAU,MAAM,CAAC;CACjE,MAAM,YAAY,kBAAkB,MAAM,EAAE;AAI5C,QAAO;EACN,QAHA,yBAAyB,kBAAkB;EAIhC;EACX;;;;;;;AAQF,SAAgB,oBAAoB,OAAmB,QAAiC;AACvF,KAAI,MAAM,WAAW,iBACpB,OAAM,IAAI,MAAM,uBAAuB;CAExC,MAAM,OAAO,yBAAyB;CACtC,MAAM,eAAe,IAAI,WAAW,MAAM,SAAS,EAAE;AACrD,cAAa,IAAI,CAAC,KAAK,CAAC;AACxB,cAAa,IAAI,OAAO,EAAE;AAC1B,QAAO,OAAO,OAAO,2BAA2B,OAAO,QAAQ,aAAa,CAAC"}

package/dist/cryptography/mnemonics.d.mts

@@ -0,0 +1,31 @@
+//#region src/cryptography/mnemonics.d.ts
+/**
+ * Parse and validate a path that is compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+ *
+ * @param path path string (e.g. `m/44'/784'/0'/0'/0'`).
+ */
+declare function isValidHardenedPath(path: string): boolean;
+/**
+ * Parse and validate a path that is compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}
+ * for Secp256k1 and m/74'/784'/{account_index}'/{change_index}/{address_index} for Secp256r1.
+ *
+ * Note that the purpose for Secp256k1 is registered as 54, to differentiate from Ed25519 with purpose 44.
+ *
+ * @param path path string (e.g. `m/54'/784'/0'/0/0`).
+ */
+declare function isValidBIP32Path(path: string): boolean;
+/**
+ * Uses KDF to derive 64 bytes of key data from mnemonic with empty password.
+ *
+ * @param mnemonics 12 words string split by spaces.
+ */
+declare function mnemonicToSeed(mnemonics: string): Uint8Array;
+/**
+ * Derive the seed in hex format from a 12-word mnemonic string.
+ *
+ * @param mnemonics 12 words string split by spaces.
+ */
+declare function mnemonicToSeedHex(mnemonics: string): string;
+//#endregion
+export { isValidBIP32Path, isValidHardenedPath, mnemonicToSeed, mnemonicToSeedHex };
+//# sourceMappingURL=mnemonics.d.mts.map

package/dist/cryptography/mnemonics.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonics.d.mts","names":[],"sources":["../../src/cryptography/mnemonics.ts"],"sourcesContent":[],"mappings":";;AAUA;AAeA;AAYA;AASA;iBApCgB,mBAAA;;;;;;;;;iBAeA,gBAAA;;;;;;iBAYA,cAAA,qBAAmC;;;;;;iBASnC,iBAAA"}

package/dist/cryptography/mnemonics.mjs

@@ -0,0 +1,45 @@
+import { toHex } from "@haneullabs/bcs";
+import { mnemonicToSeedSync } from "@scure/bip39";
+
+//#region src/cryptography/mnemonics.ts
+/**
+* Parse and validate a path that is compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+*
+* @param path path string (e.g. `m/44'/784'/0'/0'/0'`).
+*/
+function isValidHardenedPath(path) {
+	if (!(/* @__PURE__ */ new RegExp("^m\\/44'\\/784'\\/[0-9]+'\\/[0-9]+'\\/[0-9]+'+$")).test(path)) return false;
+	return true;
+}
+/**
+* Parse and validate a path that is compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}
+* for Secp256k1 and m/74'/784'/{account_index}'/{change_index}/{address_index} for Secp256r1.
+*
+* Note that the purpose for Secp256k1 is registered as 54, to differentiate from Ed25519 with purpose 44.
+*
+* @param path path string (e.g. `m/54'/784'/0'/0/0`).
+*/
+function isValidBIP32Path(path) {
+	if (!(/* @__PURE__ */ new RegExp("^m\\/(54|74)'\\/784'\\/[0-9]+'\\/[0-9]+\\/[0-9]+$")).test(path)) return false;
+	return true;
+}
+/**
+* Uses KDF to derive 64 bytes of key data from mnemonic with empty password.
+*
+* @param mnemonics 12 words string split by spaces.
+*/
+function mnemonicToSeed(mnemonics) {
+	return mnemonicToSeedSync(mnemonics, "");
+}
+/**
+* Derive the seed in hex format from a 12-word mnemonic string.
+*
+* @param mnemonics 12 words string split by spaces.
+*/
+function mnemonicToSeedHex(mnemonics) {
+	return toHex(mnemonicToSeed(mnemonics));
+}
+
+//#endregion
+export { isValidBIP32Path, isValidHardenedPath, mnemonicToSeed, mnemonicToSeedHex };
+//# sourceMappingURL=mnemonics.mjs.map

package/dist/cryptography/mnemonics.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonics.mjs","names":["bip39MnemonicToSeedSync"],"sources":["../../src/cryptography/mnemonics.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { toHex } from '@haneullabs/bcs';\nimport { mnemonicToSeedSync as bip39MnemonicToSeedSync } from '@scure/bip39';\n\n/**\n * Parse and validate a path that is compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.\n *\n * @param path path string (e.g. `m/44'/784'/0'/0'/0'`).\n */\nexport function isValidHardenedPath(path: string): boolean {\n\tif (!new RegExp(\"^m\\\\/44'\\\\/784'\\\\/[0-9]+'\\\\/[0-9]+'\\\\/[0-9]+'+$\").test(path)) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\n/**\n * Parse and validate a path that is compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}\n * for Secp256k1 and m/74'/784'/{account_index}'/{change_index}/{address_index} for Secp256r1.\n *\n * Note that the purpose for Secp256k1 is registered as 54, to differentiate from Ed25519 with purpose 44.\n *\n * @param path path string (e.g. `m/54'/784'/0'/0/0`).\n */\nexport function isValidBIP32Path(path: string): boolean {\n\tif (!new RegExp(\"^m\\\\/(54|74)'\\\\/784'\\\\/[0-9]+'\\\\/[0-9]+\\\\/[0-9]+$\").test(path)) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\n/**\n * Uses KDF to derive 64 bytes of key data from mnemonic with empty password.\n *\n * @param mnemonics 12 words string split by spaces.\n */\nexport function mnemonicToSeed(mnemonics: string): Uint8Array {\n\treturn bip39MnemonicToSeedSync(mnemonics, '');\n}\n\n/**\n * Derive the seed in hex format from a 12-word mnemonic string.\n *\n * @param mnemonics 12 words string split by spaces.\n */\nexport function mnemonicToSeedHex(mnemonics: string): string {\n\treturn toHex(mnemonicToSeed(mnemonics));\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,oBAAoB,MAAuB;AAC1D,KAAI,kBAAC,IAAI,OAAO,kDAAkD,EAAC,KAAK,KAAK,CAC5E,QAAO;AAER,QAAO;;;;;;;;;;AAWR,SAAgB,iBAAiB,MAAuB;AACvD,KAAI,kBAAC,IAAI,OAAO,oDAAoD,EAAC,KAAK,KAAK,CAC9E,QAAO;AAER,QAAO;;;;;;;AAQR,SAAgB,eAAe,WAA+B;AAC7D,QAAOA,mBAAwB,WAAW,GAAG;;;;;;;AAQ9C,SAAgB,kBAAkB,WAA2B;AAC5D,QAAO,MAAM,eAAe,UAAU,CAAC"}

package/dist/cryptography/publickey.d.mts

@@ -0,0 +1,65 @@
+import { IntentScope } from "./intent.mjs";
+
+//#region src/cryptography/publickey.d.ts
+
+/**
+ * Value to be converted into public key.
+ */
+type PublicKeyInitData = string | Uint8Array | Iterable<number>;
+/**
+ * A public key
+ */
+declare abstract class PublicKey {
+  /**
+   * Checks if two public keys are equal
+   */
+  equals(publicKey: PublicKey): boolean;
+  /**
+   * Return the base-64 representation of the public key
+   */
+  toBase64(): string;
+  toString(): never;
+  /**
+   * Return the Haneul representation of the public key encoded in
+   * base-64. A Haneul public key is formed by the concatenation
+   * of the scheme flag with the raw bytes of the public key
+   */
+  toSuiPublicKey(): string;
+  verifyWithIntent(bytes: Uint8Array, signature: Uint8Array | string, intent: IntentScope): Promise<boolean>;
+  /**
+   * Verifies that the signature is valid for for the provided PersonalMessage
+   */
+  verifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+  /**
+   * Verifies that the signature is valid for for the provided Transaction
+   */
+  verifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+  /**
+   * Verifies that the public key is associated with the provided address
+   */
+  verifyAddress(address: string): boolean;
+  /**
+   * Returns the bytes representation of the public key
+   * prefixed with the signature scheme flag
+   */
+  toSuiBytes(): Uint8Array<ArrayBuffer>;
+  /**
+   * Return the Haneul address associated with this Ed25519 public key
+   */
+  toHaneulAddress(): string;
+  /**
+   * Return the byte array representation of the public key
+   */
+  abstract toRawBytes(): Uint8Array<ArrayBuffer>;
+  /**
+   * Return signature scheme flag of the public key
+   */
+  abstract flag(): number;
+  /**
+   * Verifies that the signature is valid for for the provided message
+   */
+  abstract verify(data: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+}
+//#endregion
+export { PublicKey, PublicKeyInitData };
+//# sourceMappingURL=publickey.d.mts.map

package/dist/cryptography/publickey.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.d.mts","names":[],"sources":["../../src/cryptography/publickey.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;AAoBsB,KApBV,iBAAA,GAoBmB,MAAA,GApBU,UAoBV,GApBuB,QAoBvB,CAAA,MAAA,CAAA;;;;AAmC3B,uBAnCkB,SAAA,CAmClB;EAU4B;;;EAWA,MAAA,CAAA,SAAA,EApDb,SAoDa,CAAA,EAAA,OAAA;EAAuB;;;EAexC,QAAA,CAAA,CAAA,EAAA,MAAA;EAsBoB,QAAA,CAAA,CAAA,EAAA,KAAA;EAAX;;;;;;0BA7Df,uBACI,6BACH,cACN;;;;iCAU4B,uBAAuB,sBAAsB;;;;iCAW7C,uBAAuB,sBAAsB;;;;;;;;;gBAe9D,WAAW;;;;;;;;yBAsBF,WAAW;;;;;;;;wBAUZ,uBAAuB,sBAAsB"}

package/dist/cryptography/publickey.mjs

@@ -0,0 +1,105 @@
+import { HANEUL_ADDRESS_LENGTH, normalizeHaneulAddress } from "../utils/haneul-types.mjs";
+import { bcs as suiBcs } from "../bcs/index.mjs";
+import { messageWithIntent } from "./intent.mjs";
+import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_SIZE } from "./signature-scheme.mjs";
+import { fromBase64, toBase64 } from "@haneullabs/bcs";
+import { blake2b } from "@noble/hashes/blake2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+
+//#region src/cryptography/publickey.ts
+function bytesEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+/**
+* A public key
+*/
+var PublicKey = class {
+	/**
+	* Checks if two public keys are equal
+	*/
+	equals(publicKey) {
+		return bytesEqual(this.toRawBytes(), publicKey.toRawBytes());
+	}
+	/**
+	* Return the base-64 representation of the public key
+	*/
+	toBase64() {
+		return toBase64(this.toRawBytes());
+	}
+	toString() {
+		throw new Error("`toString` is not implemented on public keys. Use `toBase64()` or `toRawBytes()` instead.");
+	}
+	/**
+	* Return the Haneul representation of the public key encoded in
+	* base-64. A Haneul public key is formed by the concatenation
+	* of the scheme flag with the raw bytes of the public key
+	*/
+	toSuiPublicKey() {
+		return toBase64(this.toSuiBytes());
+	}
+	verifyWithIntent(bytes, signature, intent) {
+		const digest = blake2b(messageWithIntent(intent, bytes), { dkLen: 32 });
+		return this.verify(digest, signature);
+	}
+	/**
+	* Verifies that the signature is valid for for the provided PersonalMessage
+	*/
+	verifyPersonalMessage(message, signature) {
+		return this.verifyWithIntent(suiBcs.byteVector().serialize(message).toBytes(), signature, "PersonalMessage");
+	}
+	/**
+	* Verifies that the signature is valid for for the provided Transaction
+	*/
+	verifyTransaction(transaction, signature) {
+		return this.verifyWithIntent(transaction, signature, "TransactionData");
+	}
+	/**
+	* Verifies that the public key is associated with the provided address
+	*/
+	verifyAddress(address) {
+		return this.toHaneulAddress() === address;
+	}
+	/**
+	* Returns the bytes representation of the public key
+	* prefixed with the signature scheme flag
+	*/
+	toSuiBytes() {
+		const rawBytes = this.toRawBytes();
+		const suiBytes = new Uint8Array(rawBytes.length + 1);
+		suiBytes.set([this.flag()]);
+		suiBytes.set(rawBytes, 1);
+		return suiBytes;
+	}
+	/**
+	* Return the Haneul address associated with this Ed25519 public key
+	*/
+	toHaneulAddress() {
+		return normalizeHaneulAddress(bytesToHex(blake2b(this.toSuiBytes(), { dkLen: 32 })).slice(0, HANEUL_ADDRESS_LENGTH * 2));
+	}
+};
+function parseSerializedKeypairSignature(serializedSignature) {
+	const bytes = fromBase64(serializedSignature);
+	const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+	switch (signatureScheme) {
+		case "ED25519":
+		case "Secp256k1":
+		case "Secp256r1":
+			const size = SIGNATURE_SCHEME_TO_SIZE[signatureScheme];
+			const signature = bytes.slice(1, bytes.length - size);
+			return {
+				serializedSignature,
+				signatureScheme,
+				signature,
+				publicKey: bytes.slice(1 + signature.length),
+				bytes
+			};
+		default: throw new Error("Unsupported signature scheme");
+	}
+}
+
+//#endregion
+export { PublicKey, bytesEqual, parseSerializedKeypairSignature };
+//# sourceMappingURL=publickey.mjs.map

package/dist/cryptography/publickey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.mjs","names":["bcs"],"sources":["../../src/cryptography/publickey.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64 } from '@haneullabs/bcs';\nimport { blake2b } from '@noble/hashes/blake2.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\nimport { bcs } from '../bcs/index.js';\nimport { normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from '../utils/haneul-types.js';\nimport type { IntentScope } from './intent.js';\nimport { messageWithIntent } from './intent.js';\nimport { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_SIZE } from './signature-scheme.js';\n\n/**\n * Value to be converted into public key.\n */\nexport type PublicKeyInitData = string | Uint8Array | Iterable<number>;\n\nexport function bytesEqual(a: Uint8Array, b: Uint8Array) {\n\tif (a === b) return true;\n\n\tif (a.length !== b.length) {\n\t\treturn false;\n\t}\n\n\tfor (let i = 0; i < a.length; i++) {\n\t\tif (a[i] !== b[i]) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n\n/**\n * A public key\n */\nexport abstract class PublicKey {\n\t/**\n\t * Checks if two public keys are equal\n\t */\n\tequals(publicKey: PublicKey) {\n\t\treturn bytesEqual(this.toRawBytes(), publicKey.toRawBytes());\n\t}\n\n\t/**\n\t * Return the base-64 representation of the public key\n\t */\n\ttoBase64() {\n\t\treturn toBase64(this.toRawBytes());\n\t}\n\n\ttoString(): never {\n\t\tthrow new Error(\n\t\t\t'`toString` is not implemented on public keys. Use `toBase64()` or `toRawBytes()` instead.',\n\t\t);\n\t}\n\n\t/**\n\t * Return the Haneul representation of the public key encoded in\n\t * base-64. A Haneul public key is formed by the concatenation\n\t * of the scheme flag with the raw bytes of the public key\n\t */\n\ttoSuiPublicKey(): string {\n\t\tconst bytes = this.toSuiBytes();\n\t\treturn toBase64(bytes);\n\t}\n\n\tverifyWithIntent(\n\t\tbytes: Uint8Array,\n\t\tsignature: Uint8Array | string,\n\t\tintent: IntentScope,\n\t): Promise<boolean> {\n\t\tconst intentMessage = messageWithIntent(intent, bytes);\n\t\tconst digest = blake2b(intentMessage, { dkLen: 32 });\n\n\t\treturn this.verify(digest, signature);\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided PersonalMessage\n\t */\n\tverifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\treturn this.verifyWithIntent(\n\t\t\tbcs.byteVector().serialize(message).toBytes(),\n\t\t\tsignature,\n\t\t\t'PersonalMessage',\n\t\t);\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided Transaction\n\t */\n\tverifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\treturn this.verifyWithIntent(transaction, signature, 'TransactionData');\n\t}\n\n\t/**\n\t * Verifies that the public key is associated with the provided address\n\t */\n\tverifyAddress(address: string): boolean {\n\t\treturn this.toHaneulAddress() === address;\n\t}\n\n\t/**\n\t * Returns the bytes representation of the public key\n\t * prefixed with the signature scheme flag\n\t */\n\ttoSuiBytes(): Uint8Array<ArrayBuffer> {\n\t\tconst rawBytes = this.toRawBytes();\n\t\tconst suiBytes = new Uint8Array(rawBytes.length + 1);\n\t\tsuiBytes.set([this.flag()]);\n\t\tsuiBytes.set(rawBytes, 1);\n\n\t\treturn suiBytes;\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this Ed25519 public key\n\t */\n\ttoHaneulAddress(): string {\n\t\t// Each hex char represents half a byte, hence hex address doubles the length\n\t\treturn normalizeHaneulAddress(\n\t\t\tbytesToHex(blake2b(this.toSuiBytes(), { dkLen: 32 })).slice(0, HANEUL_ADDRESS_LENGTH * 2),\n\t\t);\n\t}\n\n\t/**\n\t * Return the byte array representation of the public key\n\t */\n\tabstract toRawBytes(): Uint8Array<ArrayBuffer>;\n\n\t/**\n\t * Return signature scheme flag of the public key\n\t */\n\tabstract flag(): number;\n\n\t/**\n\t * Verifies that the signature is valid for for the provided message\n\t */\n\tabstract verify(data: Uint8Array, signature: Uint8Array | string): Promise<boolean>;\n}\n\nexport function parseSerializedKeypairSignature(serializedSignature: string) {\n\tconst bytes = fromBase64(serializedSignature);\n\n\tconst signatureScheme =\n\t\tSIGNATURE_FLAG_TO_SCHEME[bytes[0] as keyof typeof SIGNATURE_FLAG_TO_SCHEME];\n\n\tswitch (signatureScheme) {\n\t\tcase 'ED25519':\n\t\tcase 'Secp256k1':\n\t\tcase 'Secp256r1':\n\t\t\tconst size =\n\t\t\t\tSIGNATURE_SCHEME_TO_SIZE[signatureScheme as keyof typeof SIGNATURE_SCHEME_TO_SIZE];\n\t\t\tconst signature = bytes.slice(1, bytes.length - size);\n\t\t\tconst publicKey = bytes.slice(1 + signature.length);\n\n\t\t\treturn {\n\t\t\t\tserializedSignature,\n\t\t\t\tsignatureScheme,\n\t\t\t\tsignature,\n\t\t\t\tpublicKey,\n\t\t\t\tbytes,\n\t\t\t};\n\t\tdefault:\n\t\t\tthrow new Error('Unsupported signature scheme');\n\t}\n}\n"],"mappings":";;;;;;;;;AAkBA,SAAgB,WAAW,GAAe,GAAe;AACxD,KAAI,MAAM,EAAG,QAAO;AAEpB,KAAI,EAAE,WAAW,EAAE,OAClB,QAAO;AAGR,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,IAC7B,KAAI,EAAE,OAAO,EAAE,GACd,QAAO;AAGT,QAAO;;;;;AAMR,IAAsB,YAAtB,MAAgC;;;;CAI/B,OAAO,WAAsB;AAC5B,SAAO,WAAW,KAAK,YAAY,EAAE,UAAU,YAAY,CAAC;;;;;CAM7D,WAAW;AACV,SAAO,SAAS,KAAK,YAAY,CAAC;;CAGnC,WAAkB;AACjB,QAAM,IAAI,MACT,4FACA;;;;;;;CAQF,iBAAyB;AAExB,SAAO,SADO,KAAK,YAAY,CACT;;CAGvB,iBACC,OACA,WACA,QACmB;EAEnB,MAAM,SAAS,QADO,kBAAkB,QAAQ,MAAM,EAChB,EAAE,OAAO,IAAI,CAAC;AAEpD,SAAO,KAAK,OAAO,QAAQ,UAAU;;;;;CAMtC,sBAAsB,SAAqB,WAAkD;AAC5F,SAAO,KAAK,iBACXA,OAAI,YAAY,CAAC,UAAU,QAAQ,CAAC,SAAS,EAC7C,WACA,kBACA;;;;;CAMF,kBAAkB,aAAyB,WAAkD;AAC5F,SAAO,KAAK,iBAAiB,aAAa,WAAW,kBAAkB;;;;;CAMxE,cAAc,SAA0B;AACvC,SAAO,KAAK,iBAAiB,KAAK;;;;;;CAOnC,aAAsC;EACrC,MAAM,WAAW,KAAK,YAAY;EAClC,MAAM,WAAW,IAAI,WAAW,SAAS,SAAS,EAAE;AACpD,WAAS,IAAI,CAAC,KAAK,MAAM,CAAC,CAAC;AAC3B,WAAS,IAAI,UAAU,EAAE;AAEzB,SAAO;;;;;CAMR,kBAA0B;AAEzB,SAAO,uBACN,WAAW,QAAQ,KAAK,YAAY,EAAE,EAAE,OAAO,IAAI,CAAC,CAAC,CAAC,MAAM,GAAG,wBAAwB,EAAE,CACzF;;;AAmBH,SAAgB,gCAAgC,qBAA6B;CAC5E,MAAM,QAAQ,WAAW,oBAAoB;CAE7C,MAAM,kBACL,yBAAyB,MAAM;AAEhC,SAAQ,iBAAR;EACC,KAAK;EACL,KAAK;EACL,KAAK;GACJ,MAAM,OACL,yBAAyB;GAC1B,MAAM,YAAY,MAAM,MAAM,GAAG,MAAM,SAAS,KAAK;AAGrD,UAAO;IACN;IACA;IACA;IACA,WANiB,MAAM,MAAM,IAAI,UAAU,OAAO;IAOlD;IACA;EACF,QACC,OAAM,IAAI,MAAM,+BAA+B"}

package/dist/cryptography/signature-scheme.d.mts

@@ -0,0 +1,28 @@
+//#region src/cryptography/signature-scheme.d.ts
+declare const SIGNATURE_SCHEME_TO_FLAG: {
+  readonly ED25519: 0;
+  readonly Secp256k1: 1;
+  readonly Secp256r1: 2;
+  readonly MultiSig: 3;
+  readonly ZkLogin: 5;
+  readonly Passkey: 6;
+};
+declare const SIGNATURE_SCHEME_TO_SIZE: {
+  ED25519: number;
+  Secp256k1: number;
+  Secp256r1: number;
+  Passkey: number;
+};
+declare const SIGNATURE_FLAG_TO_SCHEME: {
+  readonly 0: "ED25519";
+  readonly 1: "Secp256k1";
+  readonly 2: "Secp256r1";
+  readonly 3: "MultiSig";
+  readonly 5: "ZkLogin";
+  readonly 6: "Passkey";
+};
+type SignatureScheme = 'ED25519' | 'Secp256k1' | 'Secp256r1' | 'MultiSig' | 'ZkLogin' | 'Passkey';
+type SignatureFlag = keyof typeof SIGNATURE_FLAG_TO_SCHEME;
+//#endregion
+export { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG, SIGNATURE_SCHEME_TO_SIZE, SignatureFlag, SignatureScheme };
+//# sourceMappingURL=signature-scheme.d.mts.map

package/dist/cryptography/signature-scheme.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature-scheme.d.mts","names":[],"sources":["../../src/cryptography/signature-scheme.ts"],"sourcesContent":[],"mappings":";cAGa;EAAA,SAAA,OAAA,EAAA,CAAA;EASA,SAAA,SAAA,EAAA,CAAA;EAOA,SAAA,SAAA,EAAA,CAAA;EASD,SAAA,QAAA,EAAe,CAAA;EAQf,SAAA,OAAa,EAAA,CAAA;;;cAxBZ;;;;;;cAOA;;;;;;;;KASD,eAAA;KAQA,aAAA,gBAA6B"}

package/dist/cryptography/signature-scheme.mjs

@@ -0,0 +1,27 @@
+//#region src/cryptography/signature-scheme.ts
+const SIGNATURE_SCHEME_TO_FLAG = {
+	ED25519: 0,
+	Secp256k1: 1,
+	Secp256r1: 2,
+	MultiSig: 3,
+	ZkLogin: 5,
+	Passkey: 6
+};
+const SIGNATURE_SCHEME_TO_SIZE = {
+	ED25519: 32,
+	Secp256k1: 33,
+	Secp256r1: 33,
+	Passkey: 33
+};
+const SIGNATURE_FLAG_TO_SCHEME = {
+	0: "ED25519",
+	1: "Secp256k1",
+	2: "Secp256r1",
+	3: "MultiSig",
+	5: "ZkLogin",
+	6: "Passkey"
+};
+
+//#endregion
+export { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG, SIGNATURE_SCHEME_TO_SIZE };
+//# sourceMappingURL=signature-scheme.mjs.map

package/dist/cryptography/signature-scheme.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature-scheme.mjs","names":[],"sources":["../../src/cryptography/signature-scheme.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport const SIGNATURE_SCHEME_TO_FLAG = {\n\tED25519: 0x00,\n\tSecp256k1: 0x01,\n\tSecp256r1: 0x02,\n\tMultiSig: 0x03,\n\tZkLogin: 0x05,\n\tPasskey: 0x06,\n} as const;\n\nexport const SIGNATURE_SCHEME_TO_SIZE = {\n\tED25519: 32,\n\tSecp256k1: 33,\n\tSecp256r1: 33,\n\tPasskey: 33,\n};\n\nexport const SIGNATURE_FLAG_TO_SCHEME = {\n\t0x00: 'ED25519',\n\t0x01: 'Secp256k1',\n\t0x02: 'Secp256r1',\n\t0x03: 'MultiSig',\n\t0x05: 'ZkLogin',\n\t0x06: 'Passkey',\n} as const;\n\nexport type SignatureScheme =\n\t| 'ED25519'\n\t| 'Secp256k1'\n\t| 'Secp256r1'\n\t| 'MultiSig'\n\t| 'ZkLogin'\n\t| 'Passkey';\n\nexport type SignatureFlag = keyof typeof SIGNATURE_FLAG_TO_SCHEME;\n"],"mappings":";AAGA,MAAa,2BAA2B;CACvC,SAAS;CACT,WAAW;CACX,WAAW;CACX,UAAU;CACV,SAAS;CACT,SAAS;CACT;AAED,MAAa,2BAA2B;CACvC,SAAS;CACT,WAAW;CACX,WAAW;CACX,SAAS;CACT;AAED,MAAa,2BAA2B;CACvC,GAAM;CACN,GAAM;CACN,GAAM;CACN,GAAM;CACN,GAAM;CACN,GAAM;CACN"}

package/dist/cryptography/signature.d.mts

@@ -0,0 +1,75 @@
+import { PublicKey } from "./publickey.mjs";
+import { SignatureScheme } from "./signature-scheme.mjs";
+import { MultiSigStruct } from "../multisig/publickey.mjs";
+
+//#region src/cryptography/signature.d.ts
+
+/**
+ * Pair of signature and corresponding public key
+ */
+type SerializeSignatureInput = {
+  signatureScheme: SignatureScheme;
+  /** Base64-encoded signature */
+  signature: Uint8Array;
+  /** Base64-encoded public key */
+  publicKey?: PublicKey;
+};
+/**
+ * Takes in a signature, its associated signing scheme and a public key, then serializes this data
+ */
+declare function toSerializedSignature({
+  signature,
+  signatureScheme,
+  publicKey
+}: SerializeSignatureInput): string;
+/**
+ * Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key
+ */
+declare function parseSerializedSignature(serializedSignature: string): {
+  serializedSignature: string;
+  signatureScheme: "ED25519" | "Secp256k1" | "Secp256r1";
+  signature: Uint8Array<ArrayBuffer>;
+  publicKey: Uint8Array<ArrayBuffer>;
+  bytes: Uint8Array<ArrayBuffer>;
+} | {
+  signatureScheme: "Passkey";
+  serializedSignature: string;
+  signature: Uint8Array<ArrayBufferLike>;
+  authenticatorData: Uint8Array<ArrayBufferLike>;
+  clientDataJson: string;
+  userSignature: Uint8Array<ArrayBuffer>;
+  publicKey: Uint8Array<ArrayBuffer>;
+} | {
+  serializedSignature: string;
+  signatureScheme: "ZkLogin";
+  zkLogin: {
+    inputs: {
+      proofPoints: {
+        a: string[];
+        b: string[][];
+        c: string[];
+      };
+      issBase64Details: {
+        value: string;
+        indexMod4: number;
+      };
+      headerBase64: string;
+      addressSeed: string;
+    };
+    maxEpoch: string;
+    userSignature: Uint8Array<ArrayBufferLike>;
+    iss: string;
+    addressSeed: bigint;
+  };
+  signature: Uint8Array<ArrayBufferLike>;
+  publicKey: Uint8Array<ArrayBuffer>;
+} | {
+  serializedSignature: string;
+  signatureScheme: "MultiSig";
+  multisig: MultiSigStruct;
+  bytes: Uint8Array<ArrayBuffer>;
+  signature: undefined;
+};
+//#endregion
+export { SerializeSignatureInput, parseSerializedSignature, toSerializedSignature };
+//# sourceMappingURL=signature.d.mts.map

package/dist/cryptography/signature.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.mts","names":[],"sources":["../../src/cryptography/signature.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAiBA;AACkB,KADN,uBAAA,GACM;EAEN,eAAA,EAFM,eAEN;EAEC;EAAS,SAAA,EAFV,UAEU;EAMN;EACf,SAAA,CAAA,EAPY,SAOZ;CACA;;;;AAkBe,iBApBA,qBAAA,CAoBwB;EAAA,SAAA;EAAA,eAAA;EAAA;AAAA,CAAA,EAhBrC,uBAgBqC,CAAA,EAAA,MAAA;;;;iBAAxB,wBAAA"}

package/dist/cryptography/signature.mjs

@@ -0,0 +1,46 @@
+import { bcs as suiBcs } from "../bcs/index.mjs";
+import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from "./signature-scheme.mjs";
+import { parseSerializedKeypairSignature } from "./publickey.mjs";
+import { parseSerializedPasskeySignature } from "../keypairs/passkey/publickey.mjs";
+import { parseSerializedZkLoginSignature } from "../zklogin/publickey.mjs";
+import { fromBase64, toBase64 } from "@haneullabs/bcs";
+
+//#region src/cryptography/signature.ts
+/**
+* Takes in a signature, its associated signing scheme and a public key, then serializes this data
+*/
+function toSerializedSignature({ signature, signatureScheme, publicKey }) {
+	if (!publicKey) throw new Error("`publicKey` is required");
+	const pubKeyBytes = publicKey.toRawBytes();
+	const serializedSignature = new Uint8Array(1 + signature.length + pubKeyBytes.length);
+	serializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[signatureScheme]]);
+	serializedSignature.set(signature, 1);
+	serializedSignature.set(pubKeyBytes, 1 + signature.length);
+	return toBase64(serializedSignature);
+}
+/**
+* Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key
+*/
+function parseSerializedSignature(serializedSignature) {
+	const bytes = fromBase64(serializedSignature);
+	const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+	switch (signatureScheme) {
+		case "Passkey": return parseSerializedPasskeySignature(serializedSignature);
+		case "MultiSig": return {
+			serializedSignature,
+			signatureScheme,
+			multisig: suiBcs.MultiSig.parse(bytes.slice(1)),
+			bytes,
+			signature: void 0
+		};
+		case "ZkLogin": return parseSerializedZkLoginSignature(serializedSignature);
+		case "ED25519":
+		case "Secp256k1":
+		case "Secp256r1": return parseSerializedKeypairSignature(serializedSignature);
+		default: throw new Error("Unsupported signature scheme");
+	}
+}
+
+//#endregion
+export { parseSerializedSignature, toSerializedSignature };
+//# sourceMappingURL=signature.mjs.map

package/dist/cryptography/signature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.mjs","names":["bcs"],"sources":["../../src/cryptography/signature.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64 } from '@haneullabs/bcs';\n\nimport { bcs } from '../bcs/index.js';\nimport { parseSerializedPasskeySignature } from '../keypairs/passkey/publickey.js';\nimport type { MultiSigStruct } from '../multisig/publickey.js';\nimport { parseSerializedZkLoginSignature } from '../zklogin/publickey.js';\nimport { parseSerializedKeypairSignature } from './publickey.js';\nimport type { PublicKey } from './publickey.js';\nimport type { SignatureScheme } from './signature-scheme.js';\nimport { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from './signature-scheme.js';\n\n/**\n * Pair of signature and corresponding public key\n */\nexport type SerializeSignatureInput = {\n\tsignatureScheme: SignatureScheme;\n\t/** Base64-encoded signature */\n\tsignature: Uint8Array;\n\t/** Base64-encoded public key */\n\tpublicKey?: PublicKey;\n};\n\n/**\n * Takes in a signature, its associated signing scheme and a public key, then serializes this data\n */\nexport function toSerializedSignature({\n\tsignature,\n\tsignatureScheme,\n\tpublicKey,\n}: SerializeSignatureInput): string {\n\tif (!publicKey) {\n\t\tthrow new Error('`publicKey` is required');\n\t}\n\n\tconst pubKeyBytes = publicKey.toRawBytes();\n\tconst serializedSignature = new Uint8Array(1 + signature.length + pubKeyBytes.length);\n\tserializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[signatureScheme]]);\n\tserializedSignature.set(signature, 1);\n\tserializedSignature.set(pubKeyBytes, 1 + signature.length);\n\treturn toBase64(serializedSignature);\n}\n\n/**\n * Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key\n */\nexport function parseSerializedSignature(serializedSignature: string) {\n\tconst bytes = fromBase64(serializedSignature);\n\n\tconst signatureScheme =\n\t\tSIGNATURE_FLAG_TO_SCHEME[bytes[0] as keyof typeof SIGNATURE_FLAG_TO_SCHEME];\n\n\tswitch (signatureScheme) {\n\t\tcase 'Passkey':\n\t\t\treturn parseSerializedPasskeySignature(serializedSignature);\n\t\tcase 'MultiSig':\n\t\t\tconst multisig: MultiSigStruct = bcs.MultiSig.parse(bytes.slice(1));\n\t\t\treturn {\n\t\t\t\tserializedSignature,\n\t\t\t\tsignatureScheme,\n\t\t\t\tmultisig,\n\t\t\t\tbytes,\n\t\t\t\tsignature: undefined,\n\t\t\t};\n\t\tcase 'ZkLogin':\n\t\t\treturn parseSerializedZkLoginSignature(serializedSignature);\n\t\tcase 'ED25519':\n\t\tcase 'Secp256k1':\n\t\tcase 'Secp256r1':\n\t\t\treturn parseSerializedKeypairSignature(serializedSignature);\n\t\tdefault:\n\t\t\tthrow new Error('Unsupported signature scheme');\n\t}\n}\n"],"mappings":";;;;;;;;;;;AA4BA,SAAgB,sBAAsB,EACrC,WACA,iBACA,aACmC;AACnC,KAAI,CAAC,UACJ,OAAM,IAAI,MAAM,0BAA0B;CAG3C,MAAM,cAAc,UAAU,YAAY;CAC1C,MAAM,sBAAsB,IAAI,WAAW,IAAI,UAAU,SAAS,YAAY,OAAO;AACrF,qBAAoB,IAAI,CAAC,yBAAyB,iBAAiB,CAAC;AACpE,qBAAoB,IAAI,WAAW,EAAE;AACrC,qBAAoB,IAAI,aAAa,IAAI,UAAU,OAAO;AAC1D,QAAO,SAAS,oBAAoB;;;;;AAMrC,SAAgB,yBAAyB,qBAA6B;CACrE,MAAM,QAAQ,WAAW,oBAAoB;CAE7C,MAAM,kBACL,yBAAyB,MAAM;AAEhC,SAAQ,iBAAR;EACC,KAAK,UACJ,QAAO,gCAAgC,oBAAoB;EAC5D,KAAK,WAEJ,QAAO;GACN;GACA;GACA,UAJgCA,OAAI,SAAS,MAAM,MAAM,MAAM,EAAE,CAAC;GAKlE;GACA,WAAW;GACX;EACF,KAAK,UACJ,QAAO,gCAAgC,oBAAoB;EAC5D,KAAK;EACL,KAAK;EACL,KAAK,YACJ,QAAO,gCAAgC,oBAAoB;EAC5D,QACC,OAAM,IAAI,MAAM,+BAA+B"}

package/dist/faucet/faucet.d.mts

@@ -0,0 +1,25 @@
+//#region src/faucet/faucet.d.ts
+declare class FaucetRateLimitError extends Error {}
+type FaucetCoinInfo = {
+  amount: number;
+  id: string;
+  transferTxDigest: string;
+};
+type FaucetResponseV2 = {
+  status: 'Success' | FaucetFailure;
+  coins_sent: FaucetCoinInfo[] | null;
+};
+type FaucetFailure = {
+  Failure: {
+    internal: string;
+  };
+};
+declare function requestSuiFromFaucetV2(input: {
+  host: string;
+  recipient: string;
+  headers?: HeadersInit;
+}): Promise<FaucetResponseV2>;
+declare function getFaucetHost(network: 'testnet' | 'devnet' | 'localnet'): "https://faucet.testnet.haneul.io" | "https://faucet.devnet.haneul.io" | "http://127.0.0.1:9123";
+//#endregion
+export { FaucetRateLimitError, getFaucetHost, requestSuiFromFaucetV2 };
+//# sourceMappingURL=faucet.d.mts.map

package/dist/faucet/faucet.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faucet.d.mts","names":[],"sources":["../../src/faucet/faucet.ts"],"sourcesContent":[],"mappings":";cAGa,oBAAA,SAA6B,KAAA;AAAQ,KAE7C,cAAA,GAAc;EAMd,MAAA,EAAA,MAAA;EAKA,EAAA,EAAA,MAAA;EAyCiB,gBAAA,EAAA,MAAA;CAGX;KAjDN,gBAAA,GAkDJ;EAAA,MAAA,EAAA,SAAA,GAjDoB,aAiDpB;EAAA,UAAA,EAhDY,cAgDZ,EAAA,GAAA,IAAA;AAoBD,CAAA;KAjEK,aAAA;;;;;iBAyCiB,sBAAA;;;YAGX;IACV,QAAA;iBAoBe,aAAA"}