@haneullabs/haneul 0.1.0 → 2.5.0

package/src/keypairs/ed25519/ed25519-hd-key.ts

@@ -5,8 +5,8 @@
 // with @noble/hashes to be browser compatible.
 
 import { fromHex } from '@haneullabs/bcs';
-import { hmac } from '@noble/hashes/hmac';
-import { sha512 } from '@noble/hashes/sha512';
+import { hmac } from '@noble/hashes/hmac.js';
+import { sha512 } from '@noble/hashes/sha2.js';
 
 type Hex = string;
 type Path = string;
@@ -24,7 +24,7 @@ const pathRegex = new RegExp("^m(\\/[0-9]+')+$");
 const replaceDerive = (val: string): string => val.replace("'", '');
 
 const getMasterKeyFromSeed = (seed: Hex): Keys => {
-	const h = hmac.create(sha512, ED25519_CURVE);
+	const h = hmac.create(sha512, new TextEncoder().encode(ED25519_CURVE));
 	const I = h.update(fromHex(seed)).digest();
 	const IL = I.slice(0, 32);
 	const IR = I.slice(32);

package/src/keypairs/ed25519/keypair.ts

@@ -1,11 +1,11 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { ed25519 } from '@noble/curves/ed25519';
+import { ed25519 } from '@noble/curves/ed25519.js';
 
 import {
-	decodeHaneulPrivateKey,
-	encodeHaneulPrivateKey,
+	decodeSuiPrivateKey,
+	encodeSuiPrivateKey,
 	Keypair,
 	PRIVATE_KEY_SIZE,
 } from '../../cryptography/keypair.js';
@@ -46,7 +46,7 @@ export class Ed25519Keypair extends Keypair {
 				secretKey: keypair.secretKey.slice(0, 32),
 			};
 		} else {
-			const privateKey = ed25519.utils.randomPrivateKey();
+			const privateKey = ed25519.utils.randomSecretKey();
 			this.keypair = {
 				publicKey: ed25519.getPublicKey(privateKey),
 				secretKey: privateKey,
@@ -65,7 +65,7 @@ export class Ed25519Keypair extends Keypair {
 	 * Generate a new random Ed25519 keypair
 	 */
 	static generate(): Ed25519Keypair {
-		const secretKey = ed25519.utils.randomPrivateKey();
+		const secretKey = ed25519.utils.randomSecretKey();
 		return new Ed25519Keypair({
 			publicKey: ed25519.getPublicKey(secretKey),
 			secretKey,
@@ -87,10 +87,10 @@ export class Ed25519Keypair extends Keypair {
 		options?: { skipValidation?: boolean },
 	): Ed25519Keypair {
 		if (typeof secretKey === 'string') {
-			const decoded = decodeHaneulPrivateKey(secretKey);
+			const decoded = decodeSuiPrivateKey(secretKey);
 
-			if (decoded.schema !== 'ED25519') {
-				throw new Error(`Expected a ED25519 keypair, got ${decoded.schema}`);
+			if (decoded.scheme !== 'ED25519') {
+				throw new Error(`Expected a ED25519 keypair, got ${decoded.scheme}`);
 			}
 
 			return this.fromSecretKey(decoded.secretKey, options);
@@ -109,7 +109,7 @@ export class Ed25519Keypair extends Keypair {
 
 		if (!options || !options.skipValidation) {
 			const encoder = new TextEncoder();
-			const signData = encoder.encode('sui validation');
+			const signData = encoder.encode('haneul validation');
 			const signature = ed25519.sign(signData, secretKey);
 			if (!ed25519.verify(signature, signData, keypair.publicKey)) {
 				throw new Error('provided secretKey is invalid');
@@ -129,7 +129,7 @@ export class Ed25519Keypair extends Keypair {
 	 * The Bech32 secret key string for this Ed25519 keypair
 	 */
 	getSecretKey(): string {
-		return encodeHaneulPrivateKey(
+		return encodeSuiPrivateKey(
 			this.keypair.secretKey.slice(0, PRIVATE_KEY_SIZE),
 			this.getKeyScheme(),
 		);

package/src/keypairs/ed25519/publickey.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { fromBase64 } from '@haneullabs/bcs';
-import { ed25519 } from '@noble/curves/ed25519';
+import { ed25519 } from '@noble/curves/ed25519.js';
 
 import {
 	bytesEqual,

package/src/keypairs/passkey/keypair.ts

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { toBase64 } from '@haneullabs/bcs';
-import { secp256r1 } from '@noble/curves/p256';
-import { blake2b } from '@noble/hashes/blake2b';
-import { sha256 } from '@noble/hashes/sha256';
-import { randomBytes } from '@noble/hashes/utils';
+import { p256 as secp256r1 } from '@noble/curves/nist.js';
+import { blake2b } from '@noble/hashes/blake2.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { randomBytes } from '@noble/hashes/utils.js';
 
 import { PasskeyAuthenticator } from '../../bcs/bcs.js';
 import type { IntentScope, SignatureWithBytes } from '../../cryptography/index.js';
@@ -93,7 +93,7 @@ export class BrowserPasskeyProvider implements PasskeyProvider {
 
 /**
  * @experimental
- * A passkey signer used for signing transactions. This is a client side implementation for [SIP-9](https://github.com/sui-foundation/sips/blob/main/sips/sip-9.md).
+ * A passkey signer used for signing transactions. This is a client side implementation for [SIP-9](https://github.co./haneul-foundation/sips/blob/main/sips/sip-9.md).
  */
 export class PasskeyKeypair extends Signer {
 	private publicKey: Uint8Array;
@@ -110,8 +110,8 @@ export class PasskeyKeypair extends Signer {
 	 * Creates an instance of Passkey signer. If no passkey wallet had created before,
 	 * use `getPasskeyInstance`. For example:
 	 * ```
-	 * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
-	 * 	  rpName: 'Sui Passkey Example',
+	 * let provider = new BrowserPasskeyProvider('Haneul Passkey Example',{
+	 * 	  rpName: 'Haneul Passkey Example',
 	 * 	  rpId: window.location.hostname,
 	 * } as BrowserPasswordProviderOptions);
 	 * const signer = await PasskeyKeypair.getPasskeyInstance(provider);
@@ -143,8 +143,8 @@ export class PasskeyKeypair extends Signer {
 		} else {
 			const derSPKI = credential.response.getPublicKey()!;
 			const pubkeyUncompressed = parseDerSPKI(new Uint8Array(derSPKI));
-			const pubkey = secp256r1.ProjectivePoint.fromHex(pubkeyUncompressed);
-			const pubkeyCompressed = pubkey.toRawBytes(true);
+			const pubkey = secp256r1.Point.fromBytes(pubkeyUncompressed);
+			const pubkeyCompressed = pubkey.toBytes(true);
 			return new PasskeyKeypair(pubkeyCompressed, provider);
 		}
 	}
@@ -170,9 +170,12 @@ export class PasskeyKeypair extends Signer {
 		const decoder = new TextDecoder();
 		const clientDataJSONString: string = decoder.decode(clientDataJSON);
 
-		// parse the signature from DER format, normalize and convert to compressed format (33 bytes).
-		const sig = secp256r1.Signature.fromDER(new Uint8Array(credential.response.signature));
-		const normalized = sig.normalizeS().toCompactRawBytes();
+		const sig = secp256r1.Signature.fromBytes(new Uint8Array(credential.response.signature), 'der');
+		const normalizedSig = sig.hasHighS()
+			? new secp256r1.Signature(sig.r, secp256r1.Point.Fn.neg(sig.s))
+			: sig;
+
+		const normalized = normalizedSig.toBytes('compact');
 
 		if (
 			normalized.length !== PASSKEY_SIGNATURE_SIZE ||
@@ -187,7 +190,7 @@ export class PasskeyKeypair extends Signer {
 		arr.set(normalized, 1);
 		arr.set(this.publicKey, 1 + normalized.length);
 
-		// serialize all fields into a passkey signature according to https://github.com/sui-foundation/sips/blob/main/sips/sip-9.md#signature-encoding
+		// serialize all fields into a passkey signature according to https://github.co./haneul-foundation/sips/blob/main/sips/sip-9.md#signature-encoding
 		return PasskeyAuthenticator.serialize({
 			authenticatorData: authenticatorData,
 			clientDataJson: clientDataJSONString,
@@ -233,8 +236,8 @@ export class PasskeyKeypair extends Signer {
 	 *
 	 * Example usage to recover wallet with two signing calls:
 	 * ```
-	 * let provider = new BrowserPasskeyProvider('Sui Passkey Example',{
-	 *     rpName: 'Sui Passkey Example',
+	 * let provider = new BrowserPasskeyProvider('Haneul Passkey Example',{
+	 *     rpName: 'Haneul Passkey Example',
 	 * 	   rpId: window.location.hostname,
 	 * } as BrowserPasswordProviderOptions);
 	 * const testMessage = new TextEncoder().encode('Hello world!');
@@ -255,14 +258,15 @@ export class PasskeyKeypair extends Signer {
 	): Promise<PublicKey[]> {
 		const credential = await provider.get(message);
 		const fullMessage = messageFromAssertionResponse(credential.response);
-		const sig = secp256r1.Signature.fromDER(new Uint8Array(credential.response.signature));
+		const sig = secp256r1.Signature.fromBytes(new Uint8Array(credential.response.signature), 'der');
 
 		const res = [];
+		const msgHash = sha256(fullMessage);
 		for (let i = 0; i < 4; i++) {
 			const s = sig.addRecoveryBit(i);
 			try {
-				const pubkey = s.recoverPublicKey(sha256(fullMessage));
-				const pk = new PasskeyPublicKey(pubkey.toRawBytes(true));
+				const pubkey = s.recoverPublicKey(msgHash);
+				const pk = new PasskeyPublicKey(pubkey.toBytes(true));
 				res.push(pk);
 			} catch {
 				continue;

package/src/keypairs/passkey/publickey.ts

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { fromBase64, toBase64 } from '@haneullabs/bcs';
-import { secp256r1 } from '@noble/curves/p256';
-import { sha256 } from '@noble/hashes/sha256';
+import { p256 as secp256r1 } from '@noble/curves/nist.js';
+import { sha256 } from '@noble/hashes/sha2.js';
 
 import { PasskeyAuthenticator } from '../../bcs/bcs.js';
 import { bytesEqual, PublicKey } from '../../cryptography/publickey.js';
@@ -134,9 +134,12 @@ export class PasskeyPublicKey extends PublicKey {
 			return false;
 		}
 
-		const payload = new Uint8Array([...parsed.authenticatorData, ...sha256(parsed.clientDataJson)]);
+		const payload = new Uint8Array([
+			...parsed.authenticatorData,
+			...sha256(new TextEncoder().encode(parsed.clientDataJson)),
+		]);
 		const sig = parsed.userSignature.slice(1, PASSKEY_SIGNATURE_SIZE + 1);
-		return secp256r1.verify(sig, sha256(payload), pk);
+		return secp256r1.verify(sig, payload, pk);
 	}
 }
 

package/src/keypairs/secp256k1/keypair.ts

@@ -1,13 +1,11 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { secp256k1 } from '@noble/curves/secp256k1';
-import { blake2b } from '@noble/hashes/blake2b';
-import { sha256 } from '@noble/hashes/sha256';
-import { bytesToHex } from '@noble/hashes/utils';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+import { blake2b } from '@noble/hashes/blake2.js';
 import { HDKey } from '@scure/bip32';
 
-import { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from '../../cryptography/keypair.js';
+import { decodeSuiPrivateKey, encodeSuiPrivateKey, Keypair } from '../../cryptography/keypair.js';
 import { isValidBIP32Path, mnemonicToSeed } from '../../cryptography/mnemonics.js';
 import type { PublicKey } from '../../cryptography/publickey.js';
 import type { SignatureScheme } from '../../cryptography/signature-scheme.js';
@@ -40,7 +38,7 @@ export class Secp256k1Keypair extends Keypair {
 		if (keypair) {
 			this.keypair = keypair;
 		} else {
-			const secretKey: Uint8Array = secp256k1.utils.randomPrivateKey();
+			const secretKey: Uint8Array = secp256k1.utils.randomSecretKey();
 			const publicKey: Uint8Array = secp256k1.getPublicKey(secretKey, true);
 
 			this.keypair = { publicKey, secretKey };
@@ -79,10 +77,10 @@ export class Secp256k1Keypair extends Keypair {
 		options?: { skipValidation?: boolean },
 	): Secp256k1Keypair {
 		if (typeof secretKey === 'string') {
-			const decoded = decodeHaneulPrivateKey(secretKey);
+			const decoded = decodeSuiPrivateKey(secretKey);
 
-			if (decoded.schema !== 'Secp256k1') {
-				throw new Error(`Expected a Secp256k1 keypair, got ${decoded.schema}`);
+			if (decoded.scheme !== 'Secp256k1') {
+				throw new Error(`Expected a Secp256k1 keypair, got ${decoded.scheme}`);
 			}
 
 			return this.fromSecretKey(decoded.secretKey, options);
@@ -91,10 +89,11 @@ export class Secp256k1Keypair extends Keypair {
 		const publicKey: Uint8Array = secp256k1.getPublicKey(secretKey, true);
 		if (!options || !options.skipValidation) {
 			const encoder = new TextEncoder();
-			const signData = encoder.encode('sui validation');
-			const msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));
-			const signature = secp256k1.sign(msgHash, secretKey);
-			if (!secp256k1.verify(signature, msgHash, publicKey, { lowS: true })) {
+			const signData = encoder.encode('haneul validation');
+			const msgHash = blake2b(signData, { dkLen: 32 });
+			const signature = secp256k1.sign(msgHash, secretKey, { prehash: false });
+
+			if (!secp256k1.verify(signature, msgHash, publicKey, { lowS: true, prehash: false })) {
 				throw new Error('Provided secretKey is invalid');
 			}
 		}
@@ -121,18 +120,16 @@ export class Secp256k1Keypair extends Keypair {
 	 * The Bech32 secret key string for this Secp256k1 keypair
 	 */
 	getSecretKey(): string {
-		return encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());
+		return encodeSuiPrivateKey(this.keypair.secretKey, this.getKeyScheme());
 	}
 
 	/**
 	 * Return the signature for the provided data.
 	 */
 	async sign(data: Uint8Array) {
-		const msgHash = sha256(data);
-		const sig = secp256k1.sign(msgHash, this.keypair.secretKey, {
+		return secp256k1.sign(data, this.keypair.secretKey, {
 			lowS: true,
-		});
-		return sig.toCompactRawBytes() as Uint8Array<ArrayBuffer>;
+		}) as Uint8Array<ArrayBuffer>;
 	}
 
 	/**

package/src/keypairs/secp256k1/publickey.ts

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { fromBase64 } from '@haneullabs/bcs';
-import { secp256k1 } from '@noble/curves/secp256k1';
-import { sha256 } from '@noble/hashes/sha256';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
 
 import {
 	bytesEqual,
@@ -85,10 +84,6 @@ export class Secp256k1PublicKey extends PublicKey {
 			bytes = signature;
 		}
 
-		return secp256k1.verify(
-			secp256k1.Signature.fromCompact(bytes),
-			sha256(message),
-			this.toRawBytes(),
-		);
+		return secp256k1.verify(bytes, message, this.toRawBytes());
 	}
 }

package/src/keypairs/secp256r1/keypair.ts

@@ -1,13 +1,11 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { secp256r1 } from '@noble/curves/p256';
-import { blake2b } from '@noble/hashes/blake2b';
-import { sha256 } from '@noble/hashes/sha256';
-import { bytesToHex } from '@noble/hashes/utils';
+import { p256 as secp256r1 } from '@noble/curves/nist.js';
+import { blake2b } from '@noble/hashes/blake2.js';
 import { HDKey } from '@scure/bip32';
 
-import { decodeHaneulPrivateKey, encodeHaneulPrivateKey, Keypair } from '../../cryptography/keypair.js';
+import { decodeSuiPrivateKey, encodeSuiPrivateKey, Keypair } from '../../cryptography/keypair.js';
 import { isValidBIP32Path, mnemonicToSeed } from '../../cryptography/mnemonics.js';
 import type { PublicKey } from '../../cryptography/publickey.js';
 import type { SignatureScheme } from '../../cryptography/signature-scheme.js';
@@ -40,7 +38,7 @@ export class Secp256r1Keypair extends Keypair {
 		if (keypair) {
 			this.keypair = keypair;
 		} else {
-			const secretKey: Uint8Array = secp256r1.utils.randomPrivateKey();
+			const secretKey: Uint8Array = secp256r1.utils.randomSecretKey();
 			const publicKey: Uint8Array = secp256r1.getPublicKey(secretKey, true);
 
 			this.keypair = { publicKey, secretKey };
@@ -79,10 +77,10 @@ export class Secp256r1Keypair extends Keypair {
 		options?: { skipValidation?: boolean },
 	): Secp256r1Keypair {
 		if (typeof secretKey === 'string') {
-			const decoded = decodeHaneulPrivateKey(secretKey);
+			const decoded = decodeSuiPrivateKey(secretKey);
 
-			if (decoded.schema !== 'Secp256r1') {
-				throw new Error(`Expected a Secp256r1 keypair, got ${decoded.schema}`);
+			if (decoded.scheme !== 'Secp256r1') {
+				throw new Error(`Expected a Secp256r1 keypair, got ${decoded.scheme}`);
 			}
 
 			return this.fromSecretKey(decoded.secretKey, options);
@@ -91,10 +89,11 @@ export class Secp256r1Keypair extends Keypair {
 		const publicKey: Uint8Array = secp256r1.getPublicKey(secretKey, true);
 		if (!options || !options.skipValidation) {
 			const encoder = new TextEncoder();
-			const signData = encoder.encode('sui validation');
-			const msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));
-			const signature = secp256r1.sign(msgHash, secretKey, { lowS: true });
-			if (!secp256r1.verify(signature, msgHash, publicKey, { lowS: true })) {
+			const signData = encoder.encode('haneul validation');
+			const msgHash = blake2b(signData, { dkLen: 32 });
+			const signature = secp256r1.sign(msgHash, secretKey, { lowS: true, prehash: false });
+
+			if (!secp256r1.verify(signature, msgHash, publicKey, { lowS: true, prehash: false })) {
 				throw new Error('Provided secretKey is invalid');
 			}
 		}
@@ -122,18 +121,16 @@ export class Secp256r1Keypair extends Keypair {
 	 * The Bech32 secret key string for this Secp256r1 keypair
 	 */
 	getSecretKey(): string {
-		return encodeHaneulPrivateKey(this.keypair.secretKey, this.getKeyScheme());
+		return encodeSuiPrivateKey(this.keypair.secretKey, this.getKeyScheme());
 	}
 
 	/**
 	 * Return the signature for the provided data.
 	 */
 	async sign(data: Uint8Array) {
-		const msgHash = sha256(data);
-		const sig = secp256r1.sign(msgHash, this.keypair.secretKey, {
+		return secp256r1.sign(data, this.keypair.secretKey, {
 			lowS: true,
-		});
-		return sig.toCompactRawBytes() as Uint8Array<ArrayBuffer>;
+		}) as Uint8Array<ArrayBuffer>;
 	}
 
 	/**

package/src/keypairs/secp256r1/publickey.ts

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { fromBase64 } from '@haneullabs/bcs';
-import { secp256r1 } from '@noble/curves/p256';
-import { sha256 } from '@noble/hashes/sha256';
+import { p256 as secp256r1 } from '@noble/curves/nist.js';
 
 import { bytesEqual, PublicKey } from '../../cryptography/publickey.js';
 import type { PublicKeyInitData } from '../../cryptography/publickey.js';
@@ -82,10 +81,6 @@ export class Secp256r1PublicKey extends PublicKey {
 			bytes = signature;
 		}
 
-		return secp256r1.verify(
-			secp256r1.Signature.fromCompact(bytes),
-			sha256(message),
-			this.toRawBytes(),
-		);
+		return secp256r1.verify(bytes, message, this.toRawBytes());
 	}
 }

package/src/multisig/publickey.ts

@@ -2,8 +2,8 @@
 // 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 { blake2b } from '@noble/hashes/blake2.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
 
 import { bcs } from '../bcs/index.js';
 import type { Signer } from '../cryptography/keypair.js';
@@ -15,11 +15,10 @@ import {
 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';
+import type { ClientWithCoreApi } from '../client/core.js';
 
 type CompressedSignature =
 	| { ED25519: Uint8Array }
@@ -78,7 +77,7 @@ export class MultiSigPublicKey extends PublicKey {
 		 *  MultiSig public key as buffer or base-64 encoded string
 		 */
 		value: string | Uint8Array | MultiSigPublicKeyStruct,
-		options: { client?: ZkLoginCompatibleClient } = {},
+		options: { client?: ClientWithCoreApi } = {},
 	) {
 		super();
 
@@ -198,7 +197,7 @@ export class MultiSigPublicKey extends PublicKey {
 		// 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();
+			const bytes = publicKey.toSuiBytes();
 			tmp.set(bytes, i);
 			i += bytes.length;
 			tmp.set([weight], i++);
@@ -268,10 +267,9 @@ export class MultiSigPublicKey extends PublicKey {
 
 			let publicKey;
 			if (parsed.signatureScheme === 'ZkLogin') {
-				publicKey = toZkLoginPublicIdentifier(
-					parsed.zkLogin?.addressSeed,
-					parsed.zkLogin?.iss,
-				).toRawBytes();
+				publicKey = toZkLoginPublicIdentifier(parsed.zkLogin?.addressSeed, parsed.zkLogin?.iss, {
+					legacyAddress: false,
+				}).toRawBytes();
 			} else {
 				publicKey = parsed.publicKey;
 			}
@@ -317,7 +315,7 @@ export class MultiSigPublicKey extends PublicKey {
  */
 export function parsePartialSignatures(
 	multisig: MultiSigStruct,
-	options: { client?: ZkLoginCompatibleClient } = {},
+	options: { client?: ClientWithCoreApi } = {},
 ): ParsedPartialMultiSigSignature[] {
 	const res: ParsedPartialMultiSigSignature[] = new Array(multisig.sigs.length);
 	for (let i = 0; i < multisig.sigs.length; i++) {

package/src/multisig/signer.ts

@@ -58,13 +58,6 @@ export class MultiSigSigner extends Signer {
 		);
 	}
 
-	/** @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(

package/src/transactions/Commands.ts

@@ -17,7 +17,7 @@ export type TransactionArgument =
 export type TransactionInput = CallArg;
 
 // Keep in sync with constants in
-// crates/sui-framework/packages/sui-framework/sources/package.move
+// crate./haneul-framework/package./haneul-framework/sources/package.move
 export enum UpgradePolicy {
 	COMPATIBLE = 0,
 	ADDITIVE = 128,
@@ -31,7 +31,7 @@ type TransactionShape<T extends Command['$kind']> = { $kind: T } & {
 /**
  * Simple helpers used to construct transactions:
  */
-export const Commands = {
+export const TransactionCommands = {
 	MoveCall(
 		input:
 			| {

package/src/transactions/Inputs.ts

@@ -5,7 +5,13 @@ import { toBase64 } from '@haneullabs/bcs';
 import type { SerializedBcs } from '@haneullabs/bcs';
 
 import { normalizeHaneulAddress } from '../utils/haneul-types.js';
-import type { CallArg, ObjectRef } from './data/internal.js';
+import type {
+	CallArg,
+	ObjectRef,
+	Reservation,
+	WithdrawalTypeArg,
+	WithdrawFrom,
+} from './data/internal.js';
 
 function Pure(data: Uint8Array | SerializedBcs<any>): Extract<CallArg, { Pure: unknown }> {
 	return {
@@ -65,4 +71,22 @@ export const Inputs = {
 			},
 		};
 	},
+	FundsWithdrawal({
+		reservation,
+		typeArg,
+		withdrawFrom,
+	}: {
+		reservation: Reservation;
+		typeArg: WithdrawalTypeArg;
+		withdrawFrom: WithdrawFrom;
+	}): Extract<CallArg, { FundsWithdrawal: unknown }> {
+		return {
+			$kind: 'FundsWithdrawal',
+			FundsWithdrawal: {
+				reservation,
+				typeArg,
+				withdrawFrom,
+			},
+		};
+	},
 };

package/src/transactions/ObjectCache.ts

@@ -3,7 +3,7 @@
 
 import type { bcs } from '../bcs/index.js';
 import { normalizeHaneulAddress } from '../utils/haneul-types.js';
-import type { OpenMoveTypeSignature } from './data/internal.js';
+import type { HaneulClientTypes } from '../client/types.js';
 import type { TransactionPlugin } from './resolve.js';
 
 export interface ObjectCacheEntry {
@@ -18,7 +18,7 @@ export interface MoveFunctionCacheEntry {
 	package: string;
 	module: string;
 	function: string;
-	parameters: OpenMoveTypeSignature[];
+	parameters: HaneulClientTypes.OpenSignature[];
 }
 
 export interface CacheEntryTypes {