@haneullabs/haneul 0.1.0

package/src/utils/haneulns.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+const HANEUL_NS_NAME_REGEX =
+	/^(?!.*(^(?!@)|[-.@])($|[-.@]))(?:[a-z0-9-]{0,63}(?:\.[a-z0-9-]{0,63})*)?@[a-z0-9-]{0,63}$/i;
+const HANEUL_NS_DOMAIN_REGEX = /^(?!.*(^|[-.])($|[-.]))(?:[a-z0-9-]{0,63}\.)+haneul$/i;
+const MAX_HANEUL_NS_NAME_LENGTH = 235;
+
+export function isValidHaneulNSName(name: string): boolean {
+	if (name.length > MAX_HANEUL_NS_NAME_LENGTH) {
+		return false;
+	}
+
+	if (name.includes('@')) {
+		return HANEUL_NS_NAME_REGEX.test(name);
+	}
+
+	return HANEUL_NS_DOMAIN_REGEX.test(name);
+}
+
+export function normalizeHaneulNSName(name: string, format: 'at' | 'dot' = 'at'): string {
+	const lowerCase = name.toLowerCase();
+	let parts;
+
+	if (lowerCase.includes('@')) {
+		if (!HANEUL_NS_NAME_REGEX.test(lowerCase)) {
+			throw new Error(`Invalid HaneulNS name ${name}`);
+		}
+		const [labels, domain] = lowerCase.split('@');
+		parts = [...(labels ? labels.split('.') : []), domain];
+	} else {
+		if (!HANEUL_NS_DOMAIN_REGEX.test(lowerCase)) {
+			throw new Error(`Invalid HaneulNS name ${name}`);
+		}
+		parts = lowerCase.split('.').slice(0, -1);
+	}
+
+	if (format === 'dot') {
+		return `${parts.join('.')}.haneul`;
+	}
+
+	return `${parts.slice(0, -1).join('.')}@${parts[parts.length - 1]}`;
+}

package/src/utils/index.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export { formatAddress, formatDigest } from './format.js';
+export {
+	isValidHaneulAddress,
+	isValidHaneulObjectId,
+	isValidTransactionDigest,
+	normalizeStructTag,
+	normalizeHaneulAddress,
+	normalizeHaneulObjectId,
+	parseStructTag,
+	HANEUL_ADDRESS_LENGTH,
+} from './haneul-types.js';
+
+export {
+	fromB64,
+	toB64,
+	fromHEX,
+	toHex,
+	toHEX,
+	fromHex,
+	fromBase64,
+	toBase64,
+	fromBase58,
+	toBase58,
+} from '@haneullabs/bcs';
+export { isValidHaneulNSName, normalizeHaneulNSName } from './haneulns.js';
+
+export {
+	HANEUL_DECIMALS,
+	GEUNHWA_PER_HANEUL,
+	MOVE_STDLIB_ADDRESS,
+	HANEUL_FRAMEWORK_ADDRESS,
+	HANEUL_SYSTEM_ADDRESS,
+	HANEUL_CLOCK_OBJECT_ID,
+	HANEUL_SYSTEM_MODULE_NAME,
+	HANEUL_TYPE_ARG,
+	HANEUL_SYSTEM_STATE_OBJECT_ID,
+	HANEUL_RANDOM_OBJECT_ID,
+} from './constants.js';
+
+export { isValidNamedPackage, isValidNamedType } from './move-registry.js';
+
+export { deriveDynamicFieldID } from './dynamic-fields.js';
+
+export { deriveObjectID } from './derived-objects.js';
+export { normalizeTypeTag } from '../bcs/type-tag-serializer.js';

package/src/utils/move-registry.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { isValidHaneulNSName } from './haneulns.js';
+
+/** The pattern to find an optionally versioned name */
+const NAME_PATTERN = /^([a-z0-9]+(?:-[a-z0-9]+)*)$/;
+/** The pattern for a valid version number */
+const VERSION_REGEX = /^\d+$/;
+/** The maximum size for an app */
+const MAX_APP_SIZE = 64;
+/** The separator for the name */
+const NAME_SEPARATOR = '/';
+
+export const isValidNamedPackage = (name: string): boolean => {
+	const parts = name.split(NAME_SEPARATOR);
+	// The name has to have 2 parts (without-version), or 3 parts (with version).
+	if (parts.length < 2 || parts.length > 3) return false;
+
+	const [org, app, version] = parts; // split by {org} {app} {optional version}
+
+	// If the version exists, it must be a number.
+	if (version !== undefined && !VERSION_REGEX.test(version)) return false;
+	// Check if the org is a valid HaneulNS name.
+	if (!isValidHaneulNSName(org)) return false;
+
+	// Check if the app is a valid name.
+	return NAME_PATTERN.test(app) && app.length < MAX_APP_SIZE;
+};
+
+/**
+ * Checks if a type contains valid named packages.
+ * This DOES NOT check if the type is a valid Move type.
+ */
+export const isValidNamedType = (type: string): boolean => {
+	// split our type by all possible type delimeters.
+	const splitType = type.split(/::|<|>|,/);
+	for (const t of splitType) {
+		if (t.includes(NAME_SEPARATOR) && !isValidNamedPackage(t)) return false;
+	}
+	// TODO: Add `isValidStructTag` check once it's introduced.
+	return true;
+};

package/src/verify/index.ts

@@ -0,0 +1,11 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// eslint-disable-next-line import/no-cycle
+export {
+	verifySignature,
+	verifyPersonalMessageSignature,
+	verifyTransactionSignature,
+	publicKeyFromRawBytes,
+	publicKeyFromSuiBytes,
+} from './verify.js';

package/src/verify/verify.ts

@@ -0,0 +1,149 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase64 } from '@haneullabs/bcs';
+
+import type { PublicKey, SignatureFlag, SignatureScheme } from '../cryptography/index.js';
+import { parseSerializedSignature, SIGNATURE_FLAG_TO_SCHEME } from '../cryptography/index.js';
+import { Ed25519PublicKey } from '../keypairs/ed25519/publickey.js';
+import { PasskeyPublicKey } from '../keypairs/passkey/publickey.js';
+import { Secp256k1PublicKey } from '../keypairs/secp256k1/publickey.js';
+import { Secp256r1PublicKey } from '../keypairs/secp256r1/publickey.js';
+// eslint-disable-next-line import/no-cycle
+import { MultiSigPublicKey } from '../multisig/publickey.js';
+import type { ZkLoginCompatibleClient } from '../zklogin/publickey.js';
+import { ZkLoginPublicIdentifier } from '../zklogin/publickey.js';
+
+export async function verifySignature(
+	bytes: Uint8Array,
+	signature: string,
+	options?: {
+		address?: string;
+	},
+): Promise<PublicKey> {
+	const parsedSignature = parseSignature(signature);
+
+	if (!(await parsedSignature.publicKey.verify(bytes, parsedSignature.serializedSignature))) {
+		throw new Error(`Signature is not valid for the provided data`);
+	}
+
+	if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+		throw new Error(`Signature is not valid for the provided address`);
+	}
+
+	return parsedSignature.publicKey;
+}
+
+export async function verifyPersonalMessageSignature(
+	message: Uint8Array,
+	signature: string,
+	options: { client?: ZkLoginCompatibleClient; address?: string } = {},
+): Promise<PublicKey> {
+	const parsedSignature = parseSignature(signature, options);
+
+	if (
+		!(await parsedSignature.publicKey.verifyPersonalMessage(
+			message,
+			parsedSignature.serializedSignature,
+		))
+	) {
+		throw new Error(`Signature is not valid for the provided message`);
+	}
+
+	if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+		throw new Error(`Signature is not valid for the provided address`);
+	}
+
+	return parsedSignature.publicKey;
+}
+
+export async function verifyTransactionSignature(
+	transaction: Uint8Array,
+	signature: string,
+	options: { client?: ZkLoginCompatibleClient; address?: string } = {},
+): Promise<PublicKey> {
+	const parsedSignature = parseSignature(signature, options);
+
+	if (
+		!(await parsedSignature.publicKey.verifyTransaction(
+			transaction,
+			parsedSignature.serializedSignature,
+		))
+	) {
+		throw new Error(`Signature is not valid for the provided Transaction`);
+	}
+
+	if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+		throw new Error(`Signature is not valid for the provided address`);
+	}
+
+	return parsedSignature.publicKey;
+}
+
+function parseSignature(signature: string, options: { client?: ZkLoginCompatibleClient } = {}) {
+	const parsedSignature = parseSerializedSignature(signature);
+
+	if (parsedSignature.signatureScheme === 'MultiSig') {
+		return {
+			...parsedSignature,
+			publicKey: new MultiSigPublicKey(parsedSignature.multisig.multisig_pk),
+		};
+	}
+
+	const publicKey = publicKeyFromRawBytes(
+		parsedSignature.signatureScheme,
+		parsedSignature.publicKey,
+		options,
+	);
+	return {
+		...parsedSignature,
+		publicKey,
+	};
+}
+
+export function publicKeyFromRawBytes(
+	signatureScheme: SignatureScheme,
+	bytes: Uint8Array,
+	options: { client?: ZkLoginCompatibleClient; address?: string } = {},
+): PublicKey {
+	let publicKey: PublicKey;
+	switch (signatureScheme) {
+		case 'ED25519':
+			publicKey = new Ed25519PublicKey(bytes);
+			break;
+		case 'Secp256k1':
+			publicKey = new Secp256k1PublicKey(bytes);
+			break;
+		case 'Secp256r1':
+			publicKey = new Secp256r1PublicKey(bytes);
+			break;
+		case 'MultiSig':
+			publicKey = new MultiSigPublicKey(bytes);
+			break;
+		case 'ZkLogin':
+			publicKey = ZkLoginPublicIdentifier.fromBytes(bytes, options);
+			break;
+		case 'Passkey':
+			publicKey = new PasskeyPublicKey(bytes);
+			break;
+		default:
+			throw new Error(`Unsupported signature scheme ${signatureScheme}`);
+	}
+
+	if (options.address && publicKey.toHaneulAddress() !== options.address) {
+		throw new Error(`Public key bytes do not match the provided address`);
+	}
+
+	return publicKey;
+}
+
+export function publicKeyFromSuiBytes(
+	publicKey: string | Uint8Array,
+	options: { client?: ZkLoginCompatibleClient; address?: string } = {},
+) {
+	const bytes = typeof publicKey === 'string' ? fromBase64(publicKey) : publicKey;
+
+	const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0] as SignatureFlag];
+
+	return publicKeyFromRawBytes(signatureScheme, bytes.slice(1), options);
+}

package/src/version.ts

@@ -0,0 +1,7 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// This file is generated by genversion.mjs. Do not edit it directly.
+
+export const PACKAGE_VERSION = '0.1.0';
+export const TARGETED_RPC_VERSION = '1.0.0';

package/src/zklogin/address.ts

@@ -0,0 +1,101 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { blake2b } from '@noble/hashes/blake2b';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { SIGNATURE_SCHEME_TO_FLAG } from '../cryptography/signature-scheme.js';
+import { normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from '../utils/index.js';
+import { decodeJwt } from './jwt-utils.js';
+import {
+	genAddressSeed,
+	normalizeZkLoginIssuer,
+	toBigEndianBytes,
+	toPaddedBigEndianBytes,
+} from './utils.js';
+
+export function computeZkLoginAddressFromSeed(
+	addressSeed: bigint,
+	iss: string,
+	/** TODO: This default should be changed in the next major release */
+	legacyAddress = true,
+) {
+	const addressSeedBytesBigEndian = legacyAddress
+		? toBigEndianBytes(addressSeed, 32)
+		: toPaddedBigEndianBytes(addressSeed, 32);
+
+	const addressParamBytes = new TextEncoder().encode(normalizeZkLoginIssuer(iss));
+	const tmp = new Uint8Array(2 + addressSeedBytesBigEndian.length + addressParamBytes.length);
+
+	tmp.set([SIGNATURE_SCHEME_TO_FLAG.ZkLogin]);
+	tmp.set([addressParamBytes.length], 1);
+	tmp.set(addressParamBytes, 2);
+	tmp.set(addressSeedBytesBigEndian, 2 + addressParamBytes.length);
+
+	return normalizeHaneulAddress(
+		bytesToHex(blake2b(tmp, { dkLen: 32 })).slice(0, HANEUL_ADDRESS_LENGTH * 2),
+	);
+}
+
+export const MAX_HEADER_LEN_B64 = 248;
+export const MAX_PADDED_UNSIGNED_JWT_LEN = 64 * 25;
+
+export function lengthChecks(jwt: string) {
+	const [header, payload] = jwt.split('.');
+	/// Is the header small enough
+	if (header.length > MAX_HEADER_LEN_B64) {
+		throw new Error(`Header is too long`);
+	}
+
+	/// Is the combined length of (header, payload, SHA2 padding) small enough?
+	// unsigned_jwt = header + '.' + payload;
+	const L = (header.length + 1 + payload.length) * 8;
+	const K = (512 + 448 - ((L % 512) + 1)) % 512;
+
+	// The SHA2 padding is 1 followed by K zeros, followed by the length of the message
+	const padded_unsigned_jwt_len = (L + 1 + K + 64) / 8;
+
+	// The padded unsigned JWT must be less than the max_padded_unsigned_jwt_len
+	if (padded_unsigned_jwt_len > MAX_PADDED_UNSIGNED_JWT_LEN) {
+		throw new Error(`JWT is too long`);
+	}
+}
+
+export function jwtToAddress(jwt: string, userSalt: string | bigint, legacyAddress = false) {
+	lengthChecks(jwt);
+
+	const decodedJWT = decodeJwt(jwt);
+
+	return computeZkLoginAddress({
+		userSalt,
+		claimName: 'sub',
+		claimValue: decodedJWT.sub,
+		aud: decodedJWT.aud,
+		iss: decodedJWT.iss,
+		legacyAddress,
+	});
+}
+
+export interface ComputeZkLoginAddressOptions {
+	claimName: string;
+	claimValue: string;
+	userSalt: string | bigint;
+	iss: string;
+	aud: string;
+	legacyAddress?: boolean;
+}
+
+export function computeZkLoginAddress({
+	claimName,
+	claimValue,
+	iss,
+	aud,
+	userSalt,
+	legacyAddress = false,
+}: ComputeZkLoginAddressOptions) {
+	return computeZkLoginAddressFromSeed(
+		genAddressSeed(userSalt, claimName, claimValue, aud),
+		iss,
+		legacyAddress,
+	);
+}

package/src/zklogin/bcs.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { InferBcsInput } from '@haneullabs/bcs';
+import { bcs } from '@haneullabs/bcs';
+
+export const zkLoginSignature = bcs.struct('ZkLoginSignature', {
+	inputs: bcs.struct('ZkLoginSignatureInputs', {
+		proofPoints: bcs.struct('ZkLoginSignatureInputsProofPoints', {
+			a: bcs.vector(bcs.string()),
+			b: bcs.vector(bcs.vector(bcs.string())),
+			c: bcs.vector(bcs.string()),
+		}),
+		issBase64Details: bcs.struct('ZkLoginSignatureInputsClaim', {
+			value: bcs.string(),
+			indexMod4: bcs.u8(),
+		}),
+		headerBase64: bcs.string(),
+		addressSeed: bcs.string(),
+	}),
+	maxEpoch: bcs.u64(),
+	userSignature: bcs.byteVector(),
+});
+
+export type ZkLoginSignature = InferBcsInput<typeof zkLoginSignature>;
+export type ZkLoginSignatureInputs = ZkLoginSignature['inputs'];

package/src/zklogin/index.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export { getZkLoginSignature, parseZkLoginSignature } from './signature.js';
+export {
+	toBigEndianBytes,
+	toPaddedBigEndianBytes,
+	hashASCIIStrToField,
+	genAddressSeed,
+	getExtendedEphemeralPublicKey,
+} from './utils.js';
+export { computeZkLoginAddressFromSeed, computeZkLoginAddress, jwtToAddress } from './address.js';
+export type { ComputeZkLoginAddressOptions } from './address.js';
+export {
+	toZkLoginPublicIdentifier,
+	ZkLoginPublicIdentifier,
+	type ZkLoginCompatibleClient,
+} from './publickey.js';
+export type { ZkLoginSignatureInputs } from './bcs.js';
+export { poseidonHash } from './poseidon.js';
+export { generateNonce, generateRandomness } from './nonce.js';
+export { decodeJwt } from './jwt-utils.js';

package/src/zklogin/jwt-decode.ts

@@ -0,0 +1,127 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+// oxlint-disable check-tag-names
+
+/** Copied from https://github.com/auth0/jwt-decode/blob/3d372e9875ff673228a9f2d9df74e84690842a9c/lib/index.ts */
+
+/**
+The MIT License (MIT)
+
+Copyright (c) 2015 Auth0, Inc. <support@auth0.com> (http://auth0.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+export interface JwtDecodeOptions {
+	header?: boolean;
+}
+
+export interface JwtHeader {
+	typ?: string;
+	alg?: string;
+	kid?: string;
+}
+
+export interface JwtPayload {
+	iss?: string;
+	sub?: string;
+	aud?: string[] | string;
+	exp?: number;
+	nbf?: number;
+	iat?: number;
+	jti?: string;
+}
+
+export class InvalidTokenError extends Error {}
+
+InvalidTokenError.prototype.name = 'InvalidTokenError';
+
+function b64DecodeUnicode(str: string) {
+	return decodeURIComponent(
+		atob(str).replace(/(.)/g, (_m, p) => {
+			let code = (p as string).charCodeAt(0).toString(16).toUpperCase();
+			if (code.length < 2) {
+				code = '0' + code;
+			}
+			return '%' + code;
+		}),
+	);
+}
+
+function base64UrlDecode(str: string) {
+	let output = str.replace(/-/g, '+').replace(/_/g, '/');
+	switch (output.length % 4) {
+		case 0:
+			break;
+		case 2:
+			output += '==';
+			break;
+		case 3:
+			output += '=';
+			break;
+		default:
+			throw new Error('base64 string is not of the correct length');
+	}
+
+	try {
+		return b64DecodeUnicode(output);
+	} catch {
+		return atob(output);
+	}
+}
+
+export function jwtDecode<T = JwtHeader>(
+	token: string,
+	options: JwtDecodeOptions & { header: true },
+): T;
+export function jwtDecode<T = JwtPayload>(token: string, options?: JwtDecodeOptions): T;
+export function jwtDecode<T = JwtHeader | JwtPayload>(
+	token: string,
+	options?: JwtDecodeOptions,
+): T {
+	if (typeof token !== 'string') {
+		throw new InvalidTokenError('Invalid token specified: must be a string');
+	}
+
+	options ||= {};
+
+	const pos = options.header === true ? 0 : 1;
+	const part = token.split('.')[pos];
+
+	if (typeof part !== 'string') {
+		throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+	}
+
+	let decoded: string;
+	try {
+		decoded = base64UrlDecode(part);
+	} catch (e) {
+		throw new InvalidTokenError(
+			`Invalid token specified: invalid base64 for part #${pos + 1} (${(e as Error).message})`,
+		);
+	}
+
+	try {
+		return JSON.parse(decoded) as T;
+	} catch (e) {
+		throw new InvalidTokenError(
+			`Invalid token specified: invalid json for part #${pos + 1} (${(e as Error).message})`,
+		);
+	}
+}