@haneullabs/haneul 0.1.0

package/src/zklogin/jwt-utils.ts

@@ -0,0 +1,142 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { JwtPayload } from './jwt-decode.js';
+import { jwtDecode } from './jwt-decode.js';
+import { normalizeZkLoginIssuer } from './utils.js';
+
+function base64UrlCharTo6Bits(base64UrlChar: string): number[] {
+	if (base64UrlChar.length !== 1) {
+		throw new Error('Invalid base64Url character: ' + base64UrlChar);
+	}
+
+	// Define the base64URL character set
+	const base64UrlCharacterSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+	// Find the index of the input character in the base64URL character set
+	const index = base64UrlCharacterSet.indexOf(base64UrlChar);
+
+	if (index === -1) {
+		throw new Error('Invalid base64Url character: ' + base64UrlChar);
+	}
+
+	// Convert the index to a 6-bit binary string
+	const binaryString = index.toString(2).padStart(6, '0');
+
+	// Convert the binary string to an array of bits
+	const bits = Array.from(binaryString).map(Number);
+
+	return bits;
+}
+
+function base64UrlStringToBitVector(base64UrlString: string) {
+	let bitVector: number[] = [];
+	for (let i = 0; i < base64UrlString.length; i++) {
+		const base64UrlChar = base64UrlString.charAt(i);
+		const bits = base64UrlCharTo6Bits(base64UrlChar);
+		bitVector = bitVector.concat(bits);
+	}
+	return bitVector;
+}
+
+function decodeBase64URL(s: string, i: number): string {
+	if (s.length < 2) {
+		throw new Error(`Input (s = ${s}) is not tightly packed because s.length < 2`);
+	}
+	let bits = base64UrlStringToBitVector(s);
+
+	const firstCharOffset = i % 4;
+	if (firstCharOffset === 0) {
+		// skip
+	} else if (firstCharOffset === 1) {
+		bits = bits.slice(2);
+	} else if (firstCharOffset === 2) {
+		bits = bits.slice(4);
+	} else {
+		// (offset == 3)
+		throw new Error(`Input (s = ${s}) is not tightly packed because i%4 = 3 (i = ${i}))`);
+	}
+
+	const lastCharOffset = (i + s.length - 1) % 4;
+	if (lastCharOffset === 3) {
+		// skip
+	} else if (lastCharOffset === 2) {
+		bits = bits.slice(0, bits.length - 2);
+	} else if (lastCharOffset === 1) {
+		bits = bits.slice(0, bits.length - 4);
+	} else {
+		// (offset == 0)
+		throw new Error(
+			`Input (s = ${s}) is not tightly packed because (i + s.length - 1)%4 = 0 (i = ${i}))`,
+		);
+	}
+
+	if (bits.length % 8 !== 0) {
+		throw new Error(`We should never reach here...`);
+	}
+
+	const bytes = new Uint8Array(Math.floor(bits.length / 8));
+	let currentByteIndex = 0;
+	for (let i = 0; i < bits.length; i += 8) {
+		const bitChunk = bits.slice(i, i + 8);
+
+		// Convert the 8-bit chunk to a byte and add it to the bytes array
+		const byte = parseInt(bitChunk.join(''), 2);
+		bytes[currentByteIndex++] = byte;
+	}
+	return new TextDecoder().decode(bytes);
+}
+
+function verifyExtendedClaim(claim: string) {
+	// Last character of each extracted_claim must be '}' or ','
+	if (!(claim.slice(-1) === '}' || claim.slice(-1) === ',')) {
+		throw new Error('Invalid claim');
+	}
+
+	// A hack to parse the JSON key-value pair.. but it should work
+	const json = JSON.parse('{' + claim.slice(0, -1) + '}');
+	if (Object.keys(json).length !== 1) {
+		throw new Error('Invalid claim');
+	}
+	const key = Object.keys(json)[0];
+	return [key, json[key]];
+}
+
+export type Claim = {
+	value: string;
+	indexMod4: number;
+};
+
+export function extractClaimValue<R>(claim: Claim, claimName: string): R {
+	const extendedClaim = decodeBase64URL(claim.value, claim.indexMod4);
+	const [name, value] = verifyExtendedClaim(extendedClaim);
+	if (name !== claimName) {
+		throw new Error(`Invalid field name: found ${name} expected ${claimName}`);
+	}
+	return value;
+}
+
+export function decodeJwt(jwt: string): Omit<JwtPayload, 'iss' | 'aud' | 'sub'> & {
+	iss: string;
+	aud: string;
+	sub: string;
+	rawIss: string;
+} {
+	const { iss, aud, sub, ...decodedJWT } = jwtDecode(jwt);
+
+	if (!sub || !iss || !aud) {
+		throw new Error('Missing jwt data');
+	}
+
+	if (Array.isArray(aud)) {
+		throw new Error('Not supported aud. Aud is an array, string was expected.');
+	}
+
+	return {
+		...decodedJWT,
+		iss: normalizeZkLoginIssuer(iss),
+		rawIss: iss,
+		aud,
+		sub,
+	};
+}

package/src/zklogin/nonce.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { toHex } from '@haneullabs/bcs';
+import { randomBytes } from '@noble/hashes/utils';
+import { base64urlnopad } from '@scure/base';
+
+import type { PublicKey } from '../cryptography/publickey.js';
+import { poseidonHash } from './poseidon.js';
+import { toPaddedBigEndianBytes } from './utils.js';
+
+export const NONCE_LENGTH = 27;
+
+function toBigIntBE(bytes: Uint8Array) {
+	const hex = toHex(bytes);
+	if (hex.length === 0) {
+		return BigInt(0);
+	}
+	return BigInt(`0x${hex}`);
+}
+
+export function generateRandomness() {
+	// Once Node 20 enters LTS, we can just use crypto.getRandomValues(new Uint8Array(16)), but until then we use `randomBytes` to improve compatibility:
+	return String(toBigIntBE(randomBytes(16)));
+}
+
+export function generateNonce(publicKey: PublicKey, maxEpoch: number, randomness: bigint | string) {
+	const publicKeyBytes = toBigIntBE(publicKey.toHaneulBytes());
+	const eph_public_key_0 = publicKeyBytes / 2n ** 128n;
+	const eph_public_key_1 = publicKeyBytes % 2n ** 128n;
+	const bigNum = poseidonHash([eph_public_key_0, eph_public_key_1, maxEpoch, BigInt(randomness)]);
+	const Z = toPaddedBigEndianBytes(bigNum, 20);
+	const nonce = base64urlnopad.encode(Z);
+
+	if (nonce.length !== NONCE_LENGTH) {
+		throw new Error(`Length of nonce ${nonce} (${nonce.length}) is not equal to ${NONCE_LENGTH}`);
+	}
+	return nonce;
+}

package/src/zklogin/poseidon.ts

@@ -0,0 +1,64 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	poseidon1,
+	poseidon2,
+	poseidon3,
+	poseidon4,
+	poseidon5,
+	poseidon6,
+	poseidon7,
+	poseidon8,
+	poseidon9,
+	poseidon10,
+	poseidon11,
+	poseidon12,
+	poseidon13,
+	poseidon14,
+	poseidon15,
+	poseidon16,
+} from 'poseidon-lite';
+
+const poseidonNumToHashFN = [
+	poseidon1,
+	poseidon2,
+	poseidon3,
+	poseidon4,
+	poseidon5,
+	poseidon6,
+	poseidon7,
+	poseidon8,
+	poseidon9,
+	poseidon10,
+	poseidon11,
+	poseidon12,
+	poseidon13,
+	poseidon14,
+	poseidon15,
+	poseidon16,
+];
+
+export const BN254_FIELD_SIZE =
+	21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+
+export function poseidonHash(inputs: (number | bigint | string)[]): bigint {
+	inputs.forEach((x) => {
+		const b = BigInt(x);
+		if (b < 0 || b >= BN254_FIELD_SIZE) {
+			throw new Error(`Element ${b} not in the BN254 field`);
+		}
+	});
+
+	const hashFN = poseidonNumToHashFN[inputs.length - 1];
+
+	if (hashFN) {
+		return hashFN(inputs);
+	} else if (inputs.length <= 32) {
+		const hash1 = poseidonHash(inputs.slice(0, 16));
+		const hash2 = poseidonHash(inputs.slice(16));
+		return poseidonHash([hash1, hash2]);
+	} else {
+		throw new Error(`Yet to implement: Unable to hash a vector of length ${inputs.length}`);
+	}
+}

package/src/zklogin/publickey.ts

@@ -0,0 +1,286 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase64, toBase64, toHex } from '@haneullabs/bcs';
+import { blake2b } from '@noble/hashes/blake2b';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { PublicKey } from '../cryptography/publickey.js';
+import type { PublicKeyInitData } from '../cryptography/publickey.js';
+import { SIGNATURE_SCHEME_TO_FLAG } from '../cryptography/signature-scheme.js';
+import { HaneulGraphQLClient } from '../graphql/client.js';
+import { normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from '../utils/haneul-types.js';
+import type { ZkLoginSignatureInputs } from './bcs.js';
+import { extractClaimValue } from './jwt-utils.js';
+import { parseZkLoginSignature } from './signature.js';
+import { normalizeZkLoginIssuer, toBigEndianBytes, toPaddedBigEndianBytes } from './utils.js';
+import type { ClientWithExtensions, Experimental_HaneulClientTypes } from '../experimental/types.js';
+
+export interface ZkLoginCompatibleClient extends ClientWithExtensions<{
+	core: {
+		verifyZkLoginSignature: Experimental_HaneulClientTypes.TransportMethods['verifyZkLoginSignature'];
+	};
+}> {}
+
+/**
+ * A zkLogin public identifier
+ */
+export class ZkLoginPublicIdentifier extends PublicKey {
+	#data: Uint8Array<ArrayBuffer>;
+	#client?: ZkLoginCompatibleClient;
+	#legacyAddress: boolean;
+
+	/**
+	 * Create a new ZkLoginPublicIdentifier object
+	 * @param value zkLogin public identifier as buffer or base-64 encoded string
+	 */
+	constructor(value: PublicKeyInitData, { client }: { client?: ZkLoginCompatibleClient } = {}) {
+		super();
+
+		this.#client = client;
+
+		if (typeof value === 'string') {
+			this.#data = fromBase64(value);
+		} else if (value instanceof Uint8Array) {
+			this.#data = value as Uint8Array<ArrayBuffer>;
+		} else {
+			this.#data = Uint8Array.from(value);
+		}
+		this.#legacyAddress = this.#data.length !== this.#data[0] + 1 + 32;
+
+		if (this.#legacyAddress) {
+			this.#data = normalizeZkLoginPublicKeyBytes(this.#data);
+		}
+	}
+
+	static fromBytes(
+		bytes: Uint8Array,
+		{
+			client,
+			address,
+			legacyAddress,
+		}: { client?: ZkLoginCompatibleClient; address?: string; legacyAddress?: boolean } = {},
+	) {
+		let publicKey: ZkLoginPublicIdentifier;
+
+		if (legacyAddress === true) {
+			publicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, true), {
+				client,
+			});
+		} else if (legacyAddress === false) {
+			publicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, false), {
+				client,
+			});
+		} else if (address) {
+			publicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, false), {
+				client,
+			});
+
+			if (publicKey.toHaneulAddress() !== address) {
+				publicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, true), {
+					client,
+				});
+			}
+		} else {
+			publicKey = new ZkLoginPublicIdentifier(bytes, {
+				client,
+			});
+		}
+
+		if (address && publicKey.toHaneulAddress() !== address) {
+			throw new Error('Public key bytes do not match the provided address');
+		}
+
+		return publicKey;
+	}
+
+	static fromProof(address: string, proof: ZkLoginSignatureInputs) {
+		const { issBase64Details, addressSeed } = proof;
+		const iss = extractClaimValue<string>(issBase64Details, 'iss');
+
+		const legacyPublicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, {
+			legacyAddress: true,
+		});
+
+		if (legacyPublicKey.toHaneulAddress() === address) {
+			return legacyPublicKey;
+		}
+
+		const publicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, {
+			legacyAddress: false,
+		});
+
+		if (publicKey.toHaneulAddress() !== address) {
+			throw new Error('Proof does not match address');
+		}
+
+		return publicKey;
+	}
+
+	/**
+	 * Checks if two zkLogin public identifiers are equal
+	 */
+	override equals(publicKey: ZkLoginPublicIdentifier): boolean {
+		return super.equals(publicKey);
+	}
+
+	override toHaneulAddress(): string {
+		if (this.#legacyAddress) {
+			return this.#toLegacyAddress();
+		}
+
+		return super.toHaneulAddress();
+	}
+
+	#toLegacyAddress() {
+		const legacyBytes = normalizeZkLoginPublicKeyBytes(this.#data, true);
+		const addressBytes = new Uint8Array(legacyBytes.length + 1);
+		addressBytes[0] = this.flag();
+		addressBytes.set(legacyBytes, 1);
+		return normalizeHaneulAddress(
+			bytesToHex(blake2b(addressBytes, { dkLen: 32 })).slice(0, HANEUL_ADDRESS_LENGTH * 2),
+		);
+	}
+
+	/**
+	 * Return the byte array representation of the zkLogin public identifier
+	 */
+	toRawBytes(): Uint8Array<ArrayBuffer> {
+		return this.#data;
+	}
+
+	/**
+	 * Return the Haneul address associated with this ZkLogin public identifier
+	 */
+	flag(): number {
+		return SIGNATURE_SCHEME_TO_FLAG['ZkLogin'];
+	}
+
+	/**
+	 * Verifies that the signature is valid for for the provided message
+	 */
+	async verify(_message: Uint8Array, _signature: Uint8Array | string): Promise<boolean> {
+		throw Error('does not support');
+	}
+
+	/**
+	 * Verifies that the signature is valid for for the provided PersonalMessage
+	 */
+	verifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {
+		const parsedSignature = parseSerializedZkLoginSignature(signature);
+		const address = new ZkLoginPublicIdentifier(parsedSignature.publicKey).toHaneulAddress();
+
+		return graphqlVerifyZkLoginSignature({
+			address: address,
+			bytes: toBase64(message),
+			signature: parsedSignature.serializedSignature,
+			intentScope: 'PersonalMessage',
+			client: this.#client,
+		});
+	}
+
+	/**
+	 * Verifies that the signature is valid for for the provided Transaction
+	 */
+	verifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean> {
+		const parsedSignature = parseSerializedZkLoginSignature(signature);
+		const address = new ZkLoginPublicIdentifier(parsedSignature.publicKey).toHaneulAddress();
+		return graphqlVerifyZkLoginSignature({
+			address: address,
+			bytes: toBase64(transaction),
+			signature: parsedSignature.serializedSignature,
+			intentScope: 'TransactionData',
+			client: this.#client,
+		});
+	}
+
+	/**
+	 * Verifies that the public key is associated with the provided address
+	 */
+	override verifyAddress(address: string): boolean {
+		return address === super.toHaneulAddress() || address === this.#toLegacyAddress();
+	}
+}
+
+// Derive the public identifier for zklogin based on address seed and iss.
+export function toZkLoginPublicIdentifier(
+	addressSeed: bigint,
+	iss: string,
+	options?: { client?: ZkLoginCompatibleClient; legacyAddress?: boolean },
+): ZkLoginPublicIdentifier {
+	// Consists of iss_bytes_len || iss_bytes || padded_32_byte_address_seed.
+	const addressSeedBytesBigEndian = options?.legacyAddress
+		? toBigEndianBytes(addressSeed, 32)
+		: toPaddedBigEndianBytes(addressSeed, 32);
+
+	const issBytes = new TextEncoder().encode(normalizeZkLoginIssuer(iss));
+	const tmp = new Uint8Array(1 + issBytes.length + addressSeedBytesBigEndian.length);
+	tmp.set([issBytes.length], 0);
+	tmp.set(issBytes, 1);
+	tmp.set(addressSeedBytesBigEndian, 1 + issBytes.length);
+	return new ZkLoginPublicIdentifier(tmp, options);
+}
+
+function normalizeZkLoginPublicKeyBytes(bytes: Uint8Array, legacyAddress = false) {
+	const issByteLength = bytes[0] + 1;
+	const addressSeed = BigInt(`0x${toHex(bytes.slice(issByteLength))}`);
+	const seedBytes = legacyAddress
+		? toBigEndianBytes(addressSeed, 32)
+		: toPaddedBigEndianBytes(addressSeed, 32);
+	const data = new Uint8Array(issByteLength + seedBytes.length);
+	data.set(bytes.slice(0, issByteLength), 0);
+	data.set(seedBytes, issByteLength);
+	return data;
+}
+
+async function graphqlVerifyZkLoginSignature({
+	address,
+	bytes,
+	signature,
+	intentScope,
+	client = new HaneulGraphQLClient({
+		url: 'https://graphql.mainnet.haneul.io/graphql',
+	}),
+}: {
+	address: string;
+	bytes: string;
+	signature: string;
+	intentScope: 'PersonalMessage' | 'TransactionData';
+	client?: ZkLoginCompatibleClient;
+}) {
+	const resp = await client.core.verifyZkLoginSignature({
+		bytes,
+		signature,
+		intentScope,
+		author: address,
+	});
+
+	return resp.success === true && resp.errors.length === 0;
+}
+
+export function parseSerializedZkLoginSignature(signature: Uint8Array | string) {
+	const bytes = typeof signature === 'string' ? fromBase64(signature) : signature;
+
+	if (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.ZkLogin) {
+		throw new Error('Invalid signature scheme');
+	}
+
+	const signatureBytes = bytes.slice(1);
+	const { inputs, maxEpoch, userSignature } = parseZkLoginSignature(signatureBytes);
+	const { issBase64Details, addressSeed } = inputs;
+	const iss = extractClaimValue<string>(issBase64Details, 'iss');
+	const publicIdentifer = toZkLoginPublicIdentifier(BigInt(addressSeed), iss);
+	return {
+		serializedSignature: toBase64(bytes),
+		signatureScheme: 'ZkLogin' as const,
+		zkLogin: {
+			inputs,
+			maxEpoch,
+			userSignature,
+			iss,
+			addressSeed: BigInt(addressSeed),
+		},
+		signature: bytes,
+		publicKey: publicIdentifer.toRawBytes(),
+	};
+}

package/src/zklogin/signature.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase64, toBase64 } from '@haneullabs/bcs';
+
+import { SIGNATURE_SCHEME_TO_FLAG } from '../cryptography/signature-scheme.js';
+import type { ZkLoginSignature } from './bcs.js';
+import { zkLoginSignature } from './bcs.js';
+
+interface ZkLoginSignatureExtended extends Omit<ZkLoginSignature, 'userSignature'> {
+	userSignature: string | ZkLoginSignature['userSignature'];
+}
+
+function getZkLoginSignatureBytes({ inputs, maxEpoch, userSignature }: ZkLoginSignatureExtended) {
+	return zkLoginSignature
+		.serialize(
+			{
+				inputs,
+				maxEpoch,
+				userSignature:
+					typeof userSignature === 'string' ? fromBase64(userSignature) : userSignature,
+			},
+			{ maxSize: 2048 },
+		)
+		.toBytes();
+}
+
+export function getZkLoginSignature({ inputs, maxEpoch, userSignature }: ZkLoginSignatureExtended) {
+	const bytes = getZkLoginSignatureBytes({ inputs, maxEpoch, userSignature });
+	const signatureBytes = new Uint8Array(bytes.length + 1);
+	signatureBytes.set([SIGNATURE_SCHEME_TO_FLAG.ZkLogin]);
+	signatureBytes.set(bytes, 1);
+	return toBase64(signatureBytes);
+}
+
+export function parseZkLoginSignature(signature: string | Uint8Array) {
+	return zkLoginSignature.parse(typeof signature === 'string' ? fromBase64(signature) : signature);
+}

package/src/zklogin/utils.ts

@@ -0,0 +1,112 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { hexToBytes } from '@noble/hashes/utils';
+
+import type { PublicKey } from '../cryptography/publickey.js';
+import { poseidonHash } from './poseidon.js';
+
+const MAX_KEY_CLAIM_NAME_LENGTH = 32;
+const MAX_KEY_CLAIM_VALUE_LENGTH = 115;
+const MAX_AUD_VALUE_LENGTH = 145;
+const PACK_WIDTH = 248;
+
+function findFirstNonZeroIndex(bytes: Uint8Array) {
+	for (let i = 0; i < bytes.length; i++) {
+		if (bytes[i] !== 0) {
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+// Derive bytearray from num where the bytearray is padded to the left with 0s to the specified width.
+export function toPaddedBigEndianBytes(num: bigint, width: number): Uint8Array {
+	const hex = num.toString(16);
+	return hexToBytes(hex.padStart(width * 2, '0').slice(-width * 2));
+}
+
+// Derive bytearray from num where the bytearray is not padded with 0.
+export function toBigEndianBytes(num: bigint, width: number): Uint8Array {
+	const bytes = toPaddedBigEndianBytes(num, width);
+
+	const firstNonZeroIndex = findFirstNonZeroIndex(bytes);
+
+	if (firstNonZeroIndex === -1) {
+		return new Uint8Array([0]);
+	}
+
+	return bytes.slice(firstNonZeroIndex);
+}
+
+export function getExtendedEphemeralPublicKey(publicKey: PublicKey) {
+	return publicKey.toHaneulPublicKey();
+}
+
+/**
+ * Splits an array into chunks of size chunk_size. If the array is not evenly
+ * divisible by chunk_size, the first chunk will be smaller than chunk_size.
+ *
+ * E.g., arrayChunk([1, 2, 3, 4, 5], 2) => [[1], [2, 3], [4, 5]]
+ *
+ * Note: Can be made more efficient by avoiding the reverse() calls.
+ */
+export function chunkArray<T>(array: T[], chunk_size: number): T[][] {
+	const chunks = Array(Math.ceil(array.length / chunk_size));
+	const revArray = array.reverse();
+	for (let i = 0; i < chunks.length; i++) {
+		chunks[i] = revArray.slice(i * chunk_size, (i + 1) * chunk_size).reverse();
+	}
+	return chunks.reverse();
+}
+
+function bytesBEToBigInt(bytes: number[]): bigint {
+	const hex = bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
+	if (hex.length === 0) {
+		return BigInt(0);
+	}
+	return BigInt('0x' + hex);
+}
+
+// hashes an ASCII string to a field element
+export function hashASCIIStrToField(str: string, maxSize: number) {
+	if (str.length > maxSize) {
+		throw new Error(`String ${str} is longer than ${maxSize} chars`);
+	}
+
+	// Note: Padding with zeroes is safe because we are only using this function to map human-readable sequence of bytes.
+	// So the ASCII values of those characters will never be zero (null character).
+	const strPadded = str
+		.padEnd(maxSize, String.fromCharCode(0))
+		.split('')
+		.map((c) => c.charCodeAt(0));
+
+	const chunkSize = PACK_WIDTH / 8;
+	const packed = chunkArray(strPadded, chunkSize).map((chunk) => bytesBEToBigInt(chunk));
+	return poseidonHash(packed);
+}
+
+export function genAddressSeed(
+	salt: string | bigint,
+	name: string,
+	value: string,
+	aud: string,
+	max_name_length = MAX_KEY_CLAIM_NAME_LENGTH,
+	max_value_length = MAX_KEY_CLAIM_VALUE_LENGTH,
+	max_aud_length = MAX_AUD_VALUE_LENGTH,
+): bigint {
+	return poseidonHash([
+		hashASCIIStrToField(name, max_name_length),
+		hashASCIIStrToField(value, max_value_length),
+		hashASCIIStrToField(aud, max_aud_length),
+		poseidonHash([BigInt(salt)]),
+	]);
+}
+
+export function normalizeZkLoginIssuer(iss: string) {
+	if (iss === 'accounts.google.com') {
+		return 'https://accounts.google.com';
+	}
+	return iss;
+}

package/transactions/package.json

@@ -0,0 +1,6 @@
+{
+	"private": true,
+	"import": "../dist/esm/transactions/index.js",
+	"main": "../dist/cjs/transactions/index.js",
+	"sideEffects": false
+}

package/utils/package.json

@@ -0,0 +1,6 @@
+{
+	"private": true,
+	"import": "../dist/esm/utils/index.js",
+	"main": "../dist/cjs/utils/index.js",
+	"sideEffects": false
+}

package/verify/package.json

@@ -0,0 +1,6 @@
+{
+	"private": true,
+	"import": "../dist/esm/verify/index.js",
+	"main": "../dist/cjs/verify/index.js",
+	"sideEffects": false
+}