@haneullabs/haneul 0.1.0

package/src/keypairs/secp256r1/publickey.ts

@@ -0,0 +1,91 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase64 } from '@haneullabs/bcs';
+import { secp256r1 } from '@noble/curves/p256';
+import { sha256 } from '@noble/hashes/sha256';
+
+import { bytesEqual, PublicKey } from '../../cryptography/publickey.js';
+import type { PublicKeyInitData } from '../../cryptography/publickey.js';
+import { SIGNATURE_SCHEME_TO_FLAG } from '../../cryptography/signature-scheme.js';
+import { parseSerializedSignature } from '../../cryptography/signature.js';
+
+const SECP256R1_PUBLIC_KEY_SIZE = 33;
+
+/**
+ * A Secp256r1 public key
+ */
+export class Secp256r1PublicKey extends PublicKey {
+	static SIZE = SECP256R1_PUBLIC_KEY_SIZE;
+	private data: Uint8Array<ArrayBuffer>;
+
+	/**
+	 * Create a new Secp256r1PublicKey object
+	 * @param value secp256r1 public key as buffer or base-64 encoded string
+	 */
+	constructor(value: PublicKeyInitData) {
+		super();
+
+		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);
+		}
+
+		if (this.data.length !== SECP256R1_PUBLIC_KEY_SIZE) {
+			throw new Error(
+				`Invalid public key input. Expected ${SECP256R1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`,
+			);
+		}
+	}
+
+	/**
+	 * Checks if two Secp256r1 public keys are equal
+	 */
+	override equals(publicKey: Secp256r1PublicKey): boolean {
+		return super.equals(publicKey);
+	}
+
+	/**
+	 * Return the byte array representation of the Secp256r1 public key
+	 */
+	toRawBytes(): Uint8Array<ArrayBuffer> {
+		return this.data;
+	}
+
+	/**
+	 * Return the Haneul address associated with this Secp256r1 public key
+	 */
+	flag(): number {
+		return SIGNATURE_SCHEME_TO_FLAG['Secp256r1'];
+	}
+
+	/**
+	 * Verifies that the signature is valid for for the provided message
+	 */
+	async verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {
+		let bytes;
+		if (typeof signature === 'string') {
+			const parsed = parseSerializedSignature(signature);
+			if (parsed.signatureScheme !== 'Secp256r1') {
+				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 secp256r1.verify(
+			secp256r1.Signature.fromCompact(bytes),
+			sha256(message),
+			this.toRawBytes(),
+		);
+	}
+}

package/src/multisig/index.ts

@@ -0,0 +1,5 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export { MultiSigSigner } from './signer.js';
+export { type MultiSigStruct, MultiSigPublicKey, parsePartialSignatures } from './publickey.js';

package/src/multisig/publickey.ts

@@ -0,0 +1,358 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase64, toBase64 } from '@haneullabs/bcs';
+import { blake2b } from '@noble/hashes/blake2b';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { bcs } from '../bcs/index.js';
+import type { Signer } from '../cryptography/keypair.js';
+import { bytesEqual, PublicKey } from '../cryptography/publickey.js';
+import {
+	SIGNATURE_FLAG_TO_SCHEME,
+	SIGNATURE_SCHEME_TO_FLAG,
+} from '../cryptography/signature-scheme.js';
+import type { SignatureFlag, SignatureScheme } from '../cryptography/signature-scheme.js';
+import { parseSerializedSignature } from '../cryptography/signature.js';
+import { normalizeHaneulAddress } from '../utils/haneul-types.js';
+// eslint-disable-next-line import/no-cycle
+import { publicKeyFromRawBytes } from '../verify/index.js';
+import type { ZkLoginCompatibleClient } from '../zklogin/publickey.js';
+import { toZkLoginPublicIdentifier } from '../zklogin/publickey.js';
+import { MultiSigSigner } from './signer.js';
+
+type CompressedSignature =
+	| { ED25519: Uint8Array }
+	| { Secp256k1: Uint8Array }
+	| { Secp256r1: Uint8Array }
+	| { ZkLogin: Uint8Array }
+	| { Passkey: Uint8Array };
+
+type PublicKeyEnum =
+	| { ED25519: Uint8Array }
+	| { Secp256k1: Uint8Array }
+	| { Secp256r1: Uint8Array }
+	| { ZkLogin: Uint8Array }
+	| { Passkey: Uint8Array };
+
+type PubkeyEnumWeightPair = {
+	pubKey: PublicKeyEnum;
+	weight: number;
+};
+
+type MultiSigPublicKeyStruct = {
+	pk_map: PubkeyEnumWeightPair[];
+	threshold: number;
+};
+
+export type MultiSigStruct = {
+	sigs: CompressedSignature[];
+	bitmap: number;
+	multisig_pk: MultiSigPublicKeyStruct;
+};
+
+type ParsedPartialMultiSigSignature = {
+	signatureScheme: SignatureScheme;
+	signature: Uint8Array;
+	publicKey: PublicKey;
+	weight: number;
+};
+
+export const MAX_SIGNER_IN_MULTISIG = 10;
+export const MIN_SIGNER_IN_MULTISIG = 1;
+/**
+ * A MultiSig public key
+ */
+export class MultiSigPublicKey extends PublicKey {
+	private rawBytes: Uint8Array<ArrayBuffer>;
+	private multisigPublicKey: MultiSigPublicKeyStruct;
+	private publicKeys: {
+		weight: number;
+		publicKey: PublicKey;
+	}[];
+	/**
+	 * Create a new MultiSigPublicKey object
+	 */
+	constructor(
+		/**
+		 *  MultiSig public key as buffer or base-64 encoded string
+		 */
+		value: string | Uint8Array | MultiSigPublicKeyStruct,
+		options: { client?: ZkLoginCompatibleClient } = {},
+	) {
+		super();
+
+		if (typeof value === 'string') {
+			this.rawBytes = fromBase64(value);
+
+			this.multisigPublicKey = bcs.MultiSigPublicKey.parse(this.rawBytes);
+		} else if (value instanceof Uint8Array) {
+			this.rawBytes = value as Uint8Array<ArrayBuffer>;
+			this.multisigPublicKey = bcs.MultiSigPublicKey.parse(this.rawBytes);
+		} else {
+			this.multisigPublicKey = value;
+			this.rawBytes = bcs.MultiSigPublicKey.serialize(value).toBytes();
+		}
+		if (this.multisigPublicKey.threshold < 1) {
+			throw new Error('Invalid threshold');
+		}
+
+		const seenPublicKeys = new Set<string>();
+
+		this.publicKeys = this.multisigPublicKey.pk_map.map(({ pubKey, weight }) => {
+			const [scheme, bytes] = Object.entries(pubKey).filter(([name]) => name !== '$kind')[0] as [
+				SignatureScheme,
+				Uint8Array,
+			];
+			const publicKeyStr = Uint8Array.from(bytes).toString();
+
+			if (seenPublicKeys.has(publicKeyStr)) {
+				throw new Error(`Multisig does not support duplicate public keys`);
+			}
+			seenPublicKeys.add(publicKeyStr);
+
+			if (weight < 1) {
+				throw new Error(`Invalid weight`);
+			}
+
+			return {
+				publicKey: publicKeyFromRawBytes(scheme, Uint8Array.from(bytes), options),
+				weight,
+			};
+		});
+
+		const totalWeight = this.publicKeys.reduce((sum, { weight }) => sum + weight, 0);
+
+		if (this.multisigPublicKey.threshold > totalWeight) {
+			throw new Error(`Unreachable threshold`);
+		}
+
+		if (this.publicKeys.length > MAX_SIGNER_IN_MULTISIG) {
+			throw new Error(`Max number of signers in a multisig is ${MAX_SIGNER_IN_MULTISIG}`);
+		}
+
+		if (this.publicKeys.length < MIN_SIGNER_IN_MULTISIG) {
+			throw new Error(`Min number of signers in a multisig is ${MIN_SIGNER_IN_MULTISIG}`);
+		}
+	}
+	/**
+	 * 	A static method to create a new MultiSig publickey instance from a set of public keys and their associated weights pairs and threshold.
+	 */
+
+	static fromPublicKeys({
+		threshold,
+		publicKeys,
+	}: {
+		threshold: number;
+		publicKeys: { publicKey: PublicKey; weight: number }[];
+	}) {
+		return new MultiSigPublicKey({
+			pk_map: publicKeys.map(({ publicKey, weight }) => {
+				const scheme = SIGNATURE_FLAG_TO_SCHEME[publicKey.flag() as SignatureFlag];
+
+				return {
+					pubKey: { [scheme]: publicKey.toRawBytes() } as PublicKeyEnum,
+					weight,
+				};
+			}),
+			threshold,
+		});
+	}
+
+	/**
+	 * Checks if two MultiSig public keys are equal
+	 */
+	override equals(publicKey: MultiSigPublicKey): boolean {
+		return super.equals(publicKey);
+	}
+
+	/**
+	 * Return the byte array representation of the MultiSig public key
+	 */
+	toRawBytes(): Uint8Array<ArrayBuffer> {
+		return this.rawBytes;
+	}
+
+	getPublicKeys() {
+		return this.publicKeys;
+	}
+
+	getThreshold() {
+		return this.multisigPublicKey.threshold;
+	}
+
+	getSigner(...signers: [signer: Signer]) {
+		return new MultiSigSigner(this, signers);
+	}
+
+	/**
+	 * Return the Haneul address associated with this MultiSig public key
+	 */
+	override toHaneulAddress(): string {
+		// max length = 1 flag byte + (max pk size + max weight size (u8)) * max signer size + 2 threshold bytes (u16)
+		const maxLength = 1 + (64 + 1) * MAX_SIGNER_IN_MULTISIG + 2;
+		const tmp = new Uint8Array(maxLength);
+		tmp.set([SIGNATURE_SCHEME_TO_FLAG['MultiSig']]);
+
+		tmp.set(bcs.u16().serialize(this.multisigPublicKey.threshold).toBytes(), 1);
+		// The initial value 3 ensures that following data will be after the flag byte and threshold bytes
+		let i = 3;
+		for (const { publicKey, weight } of this.publicKeys) {
+			const bytes = publicKey.toHaneulBytes();
+			tmp.set(bytes, i);
+			i += bytes.length;
+			tmp.set([weight], i++);
+		}
+		return normalizeHaneulAddress(bytesToHex(blake2b(tmp.slice(0, i), { dkLen: 32 })));
+	}
+
+	/**
+	 * Return the Haneul address associated with this MultiSig public key
+	 */
+	flag(): number {
+		return SIGNATURE_SCHEME_TO_FLAG['MultiSig'];
+	}
+
+	/**
+	 * Verifies that the signature is valid for for the provided message
+	 */
+	async verify(message: Uint8Array, multisigSignature: string): Promise<boolean> {
+		// Multisig verification only supports serialized signature
+		const parsed = parseSerializedSignature(multisigSignature);
+
+		if (parsed.signatureScheme !== 'MultiSig') {
+			throw new Error('Invalid signature scheme');
+		}
+
+		const { multisig } = parsed;
+
+		let signatureWeight = 0;
+
+		if (
+			!bytesEqual(
+				bcs.MultiSigPublicKey.serialize(this.multisigPublicKey).toBytes(),
+				bcs.MultiSigPublicKey.serialize(multisig.multisig_pk).toBytes(),
+			)
+		) {
+			return false;
+		}
+
+		for (const { publicKey, weight, signature } of parsePartialSignatures(multisig)) {
+			if (!(await publicKey.verify(message, signature))) {
+				return false;
+			}
+
+			signatureWeight += weight;
+		}
+
+		return signatureWeight >= this.multisigPublicKey.threshold;
+	}
+
+	/**
+	 * Combines multiple partial signatures into a single multisig, ensuring that each public key signs only once
+	 * and that all the public keys involved are known and valid, and then serializes multisig into the standard format
+	 */
+	combinePartialSignatures(signatures: string[]): string {
+		if (signatures.length > MAX_SIGNER_IN_MULTISIG) {
+			throw new Error(`Max number of signatures in a multisig is ${MAX_SIGNER_IN_MULTISIG}`);
+		}
+
+		let bitmap = 0;
+		const compressedSignatures: CompressedSignature[] = new Array(signatures.length);
+
+		for (let i = 0; i < signatures.length; i++) {
+			const parsed = parseSerializedSignature(signatures[i]);
+			if (parsed.signatureScheme === 'MultiSig') {
+				throw new Error('MultiSig is not supported inside MultiSig');
+			}
+
+			let publicKey;
+			if (parsed.signatureScheme === 'ZkLogin') {
+				publicKey = toZkLoginPublicIdentifier(
+					parsed.zkLogin?.addressSeed,
+					parsed.zkLogin?.iss,
+				).toRawBytes();
+			} else {
+				publicKey = parsed.publicKey;
+			}
+
+			compressedSignatures[i] = {
+				[parsed.signatureScheme]: parsed.signature,
+			} as CompressedSignature;
+
+			let publicKeyIndex;
+			for (let j = 0; j < this.publicKeys.length; j++) {
+				if (bytesEqual(publicKey, this.publicKeys[j].publicKey.toRawBytes())) {
+					if (bitmap & (1 << j)) {
+						throw new Error('Received multiple signatures from the same public key');
+					}
+
+					publicKeyIndex = j;
+					break;
+				}
+			}
+
+			if (publicKeyIndex === undefined) {
+				throw new Error('Received signature from unknown public key');
+			}
+
+			bitmap |= 1 << publicKeyIndex;
+		}
+
+		const multisig: MultiSigStruct = {
+			sigs: compressedSignatures,
+			bitmap,
+			multisig_pk: this.multisigPublicKey,
+		};
+		const bytes = bcs.MultiSig.serialize(multisig, { maxSize: 8192 }).toBytes();
+		const tmp = new Uint8Array(bytes.length + 1);
+		tmp.set([SIGNATURE_SCHEME_TO_FLAG['MultiSig']]);
+		tmp.set(bytes, 1);
+		return toBase64(tmp);
+	}
+}
+
+/**
+ * Parse multisig structure into an array of individual signatures: signature scheme, the actual individual signature, public key and its weight.
+ */
+export function parsePartialSignatures(
+	multisig: MultiSigStruct,
+	options: { client?: ZkLoginCompatibleClient } = {},
+): ParsedPartialMultiSigSignature[] {
+	const res: ParsedPartialMultiSigSignature[] = new Array(multisig.sigs.length);
+	for (let i = 0; i < multisig.sigs.length; i++) {
+		const [signatureScheme, signature] = Object.entries(multisig.sigs[i]).filter(
+			([name]) => name !== '$kind',
+		)[0] as [SignatureScheme, Uint8Array];
+		const pkIndex = asIndices(multisig.bitmap).at(i)!;
+		const pair = multisig.multisig_pk.pk_map[pkIndex];
+		const pkBytes = Uint8Array.from(Object.values(pair.pubKey)[0]);
+
+		if (signatureScheme === 'MultiSig') {
+			throw new Error('MultiSig is not supported inside MultiSig');
+		}
+
+		const publicKey = publicKeyFromRawBytes(signatureScheme, pkBytes, options);
+
+		res[i] = {
+			signatureScheme,
+			signature: Uint8Array.from(signature),
+			publicKey: publicKey,
+			weight: pair.weight,
+		};
+	}
+	return res;
+}
+
+function asIndices(bitmap: number): Uint8Array {
+	if (bitmap < 0 || bitmap > 1024) {
+		throw new Error('Invalid bitmap');
+	}
+	const res: number[] = [];
+	for (let i = 0; i < 10; i++) {
+		if ((bitmap & (1 << i)) !== 0) {
+			res.push(i);
+		}
+	}
+	return Uint8Array.from(res);
+}

package/src/multisig/signer.ts

@@ -0,0 +1,93 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import { toBase64 } from '@haneullabs/bcs';
+
+import type { SignatureScheme } from '../cryptography/index.js';
+import { Signer } from '../cryptography/index.js';
+import type { MultiSigPublicKey } from './publickey.js';
+
+export class MultiSigSigner extends Signer {
+	#pubkey: MultiSigPublicKey;
+	#signers: Signer[];
+
+	constructor(pubkey: MultiSigPublicKey, signers: Signer[] = []) {
+		super();
+		this.#pubkey = pubkey;
+		this.#signers = signers;
+
+		const uniqueKeys = new Set();
+		let combinedWeight = 0;
+
+		const weights = pubkey.getPublicKeys().map(({ weight, publicKey }) => ({
+			weight,
+			address: publicKey.toHaneulAddress(),
+		}));
+
+		for (const signer of signers) {
+			const address = signer.toHaneulAddress();
+			if (uniqueKeys.has(address)) {
+				throw new Error(`Can't create MultiSigSigner with duplicate signers`);
+			}
+			uniqueKeys.add(address);
+
+			const weight = weights.find((w) => w.address === address)?.weight;
+
+			if (!weight) {
+				throw new Error(`Signer ${address} is not part of the MultiSig public key`);
+			}
+
+			combinedWeight += weight;
+		}
+
+		if (combinedWeight < pubkey.getThreshold()) {
+			throw new Error(`Combined weight of signers is less than threshold`);
+		}
+	}
+
+	getKeyScheme(): SignatureScheme {
+		return 'MultiSig';
+	}
+
+	getPublicKey(): MultiSigPublicKey {
+		return this.#pubkey;
+	}
+
+	sign(_data: Uint8Array): never {
+		throw new Error(
+			'MultiSigSigner does not support signing directly. Use signTransaction or signPersonalMessage instead',
+		);
+	}
+
+	/** @deprecated use `sign` instead */
+	signData(_data: Uint8Array): never {
+		throw new Error(
+			'MultiSigSigner does not support signing directly. Use signTransaction or signPersonalMessage instead',
+		);
+	}
+
+	async signTransaction(bytes: Uint8Array) {
+		const signature = this.#pubkey.combinePartialSignatures(
+			await Promise.all(
+				this.#signers.map(async (signer) => (await signer.signTransaction(bytes)).signature),
+			),
+		);
+
+		return {
+			signature,
+			bytes: toBase64(bytes),
+		};
+	}
+
+	async signPersonalMessage(bytes: Uint8Array) {
+		const signature = this.#pubkey.combinePartialSignatures(
+			await Promise.all(
+				this.#signers.map(async (signer) => (await signer.signPersonalMessage(bytes)).signature),
+			),
+		);
+
+		return {
+			signature,
+			bytes: toBase64(bytes),
+		};
+	}
+}

package/src/transactions/Arguments.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Argument } from './data/internal.js';
+import type { Inputs } from './Inputs.js';
+import { createObjectMethods } from './object.js';
+import { createPure } from './pure.js';
+import type { Transaction, TransactionObjectArgument } from './Transaction.js';
+
+export const Arguments = {
+	pure: createPure<(tx: Transaction) => Argument>((value) => (tx) => tx.pure(value)) as ReturnType<
+		typeof createPure<(tx: Transaction) => Argument>
+	>,
+	object: createObjectMethods<TransactionObjectArgument>((value) => (tx) => tx.object(value)),
+	sharedObjectRef:
+		(...args: Parameters<(typeof Inputs)['SharedObjectRef']>) =>
+		(tx: Transaction) =>
+			tx.sharedObjectRef(...args),
+	objectRef:
+		(...args: Parameters<(typeof Inputs)['ObjectRef']>) =>
+		(tx: Transaction) =>
+			tx.objectRef(...args),
+	receivingRef:
+		(...args: Parameters<(typeof Inputs)['ReceivingRef']>) =>
+		(tx: Transaction) =>
+			tx.receivingRef(...args),
+};