@haneullabs/haneul 0.1.0

package/src/transactions/resolve.ts

@@ -0,0 +1,124 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Argument } from './data/internal.js';
+
+import type { ClientWithCoreApi } from '../experimental/index.js';
+import type { TransactionDataBuilder } from './TransactionData.js';
+import type { BcsType } from '@haneullabs/bcs';
+import { Inputs } from './Inputs.js';
+import { bcs } from '../bcs/index.js';
+import { jsonRpcClientResolveTransactionPlugin } from '../jsonRpc/json-rpc-resolver.js';
+import type { HaneulJsonRpcClient } from '../jsonRpc/client.js';
+
+export interface BuildTransactionOptions {
+	client?: ClientWithCoreApi;
+	onlyTransactionKind?: boolean;
+}
+
+export interface SerializeTransactionOptions extends BuildTransactionOptions {
+	supportedIntents?: string[];
+}
+
+export type TransactionPlugin = (
+	transactionData: TransactionDataBuilder,
+	options: BuildTransactionOptions,
+	next: () => Promise<void>,
+) => Promise<void>;
+
+export function needsTransactionResolution(
+	data: TransactionDataBuilder,
+	options: BuildTransactionOptions,
+): boolean {
+	if (
+		data.inputs.some((input) => {
+			return input.UnresolvedObject || input.UnresolvedPure;
+		})
+	) {
+		return true;
+	}
+
+	if (!options.onlyTransactionKind) {
+		if (!data.gasConfig.price || !data.gasConfig.budget || !data.gasConfig.payment) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+export async function resolveTransactionPlugin(
+	transactionData: TransactionDataBuilder,
+	options: BuildTransactionOptions,
+	next: () => Promise<void>,
+) {
+	normalizeRawArguments(transactionData);
+	if (!needsTransactionResolution(transactionData, options)) {
+		await validate(transactionData);
+		return next();
+	}
+
+	const client = getClient(options);
+	const plugin =
+		client.core?.resolveTransactionPlugin() ??
+		jsonRpcClientResolveTransactionPlugin(client as HaneulJsonRpcClient);
+
+	return plugin(transactionData, options, async () => {
+		await validate(transactionData);
+		await next();
+	});
+}
+
+function validate(transactionData: TransactionDataBuilder) {
+	transactionData.inputs.forEach((input, index) => {
+		if (input.$kind !== 'Object' && input.$kind !== 'Pure') {
+			throw new Error(
+				`Input at index ${index} has not been resolved.  Expected a Pure or Object input, but found ${JSON.stringify(
+					input,
+				)}`,
+			);
+		}
+	});
+}
+
+export function getClient(options: BuildTransactionOptions) {
+	if (!options.client) {
+		throw new Error(
+			`No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`,
+		);
+	}
+
+	return options.client;
+}
+
+function normalizeRawArguments(transactionData: TransactionDataBuilder) {
+	for (const command of transactionData.commands) {
+		switch (command.$kind) {
+			case 'SplitCoins':
+				command.SplitCoins.amounts.forEach((amount) => {
+					normalizeRawArgument(amount, bcs.U64, transactionData);
+				});
+				break;
+			case 'TransferObjects':
+				normalizeRawArgument(command.TransferObjects.address, bcs.Address, transactionData);
+				break;
+		}
+	}
+}
+
+function normalizeRawArgument(
+	arg: Argument,
+	schema: BcsType<any>,
+	transactionData: TransactionDataBuilder,
+) {
+	if (arg.$kind !== 'Input') {
+		return;
+	}
+	const input = transactionData.inputs[arg.Input];
+
+	if (input.$kind !== 'UnresolvedPure') {
+		return;
+	}
+
+	transactionData.inputs[arg.Input] = Inputs.Pure(schema.serialize(input.UnresolvedPure.value));
+}

package/src/transactions/serializer.ts

@@ -0,0 +1,212 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { BcsType } from '@haneullabs/bcs';
+
+import { bcs } from '../bcs/index.js';
+import type { HaneulMoveNormalizedType } from '../client/index.js';
+import { MOVE_STDLIB_ADDRESS, HANEUL_FRAMEWORK_ADDRESS } from '../utils/index.js';
+import { normalizeHaneulAddress } from '../utils/haneul-types.js';
+import type { OpenMoveTypeSignature, OpenMoveTypeSignatureBody } from './data/internal.js';
+
+const OBJECT_MODULE_NAME = 'object';
+const ID_STRUCT_NAME = 'ID';
+
+const STD_ASCII_MODULE_NAME = 'ascii';
+const STD_ASCII_STRUCT_NAME = 'String';
+
+const STD_UTF8_MODULE_NAME = 'string';
+const STD_UTF8_STRUCT_NAME = 'String';
+
+const STD_OPTION_MODULE_NAME = 'option';
+const STD_OPTION_STRUCT_NAME = 'Option';
+
+export function isTxContext(param: OpenMoveTypeSignature): boolean {
+	const struct =
+		typeof param.body === 'object' && 'datatype' in param.body ? param.body.datatype : null;
+
+	return (
+		!!struct &&
+		normalizeHaneulAddress(struct.package) === normalizeHaneulAddress('0x2') &&
+		struct.module === 'tx_context' &&
+		struct.type === 'TxContext'
+	);
+}
+
+export function getPureBcsSchema(typeSignature: OpenMoveTypeSignatureBody): BcsType<any> | null {
+	if (typeof typeSignature === 'string') {
+		switch (typeSignature) {
+			case 'address':
+				return bcs.Address;
+			case 'bool':
+				return bcs.Bool;
+			case 'u8':
+				return bcs.U8;
+			case 'u16':
+				return bcs.U16;
+			case 'u32':
+				return bcs.U32;
+			case 'u64':
+				return bcs.U64;
+			case 'u128':
+				return bcs.U128;
+			case 'u256':
+				return bcs.U256;
+			default:
+				throw new Error(`Unknown type signature ${typeSignature}`);
+		}
+	}
+
+	if ('vector' in typeSignature) {
+		if (typeSignature.vector === 'u8') {
+			return bcs.byteVector().transform({
+				input: (val: string | Uint8Array) =>
+					typeof val === 'string' ? new TextEncoder().encode(val) : val,
+				output: (val) => val,
+			});
+		}
+		const type = getPureBcsSchema(typeSignature.vector);
+		return type ? bcs.vector(type) : null;
+	}
+
+	if ('datatype' in typeSignature) {
+		const pkg = normalizeHaneulAddress(typeSignature.datatype.package);
+
+		if (pkg === normalizeHaneulAddress(MOVE_STDLIB_ADDRESS)) {
+			if (
+				typeSignature.datatype.module === STD_ASCII_MODULE_NAME &&
+				typeSignature.datatype.type === STD_ASCII_STRUCT_NAME
+			) {
+				return bcs.String;
+			}
+
+			if (
+				typeSignature.datatype.module === STD_UTF8_MODULE_NAME &&
+				typeSignature.datatype.type === STD_UTF8_STRUCT_NAME
+			) {
+				return bcs.String;
+			}
+
+			if (
+				typeSignature.datatype.module === STD_OPTION_MODULE_NAME &&
+				typeSignature.datatype.type === STD_OPTION_STRUCT_NAME
+			) {
+				const type = getPureBcsSchema(typeSignature.datatype.typeParameters[0]);
+				return type ? bcs.vector(type) : null;
+			}
+		}
+
+		if (
+			pkg === normalizeHaneulAddress(HANEUL_FRAMEWORK_ADDRESS) &&
+			typeSignature.datatype.module === OBJECT_MODULE_NAME &&
+			typeSignature.datatype.type === ID_STRUCT_NAME
+		) {
+			return bcs.Address;
+		}
+	}
+
+	return null;
+}
+
+export function normalizedTypeToMoveTypeSignature(
+	type: HaneulMoveNormalizedType,
+): OpenMoveTypeSignature {
+	if (typeof type === 'object' && 'Reference' in type) {
+		return {
+			ref: '&',
+			body: normalizedTypeToMoveTypeSignatureBody(type.Reference),
+		};
+	}
+	if (typeof type === 'object' && 'MutableReference' in type) {
+		return {
+			ref: '&mut',
+			body: normalizedTypeToMoveTypeSignatureBody(type.MutableReference),
+		};
+	}
+
+	return {
+		ref: null,
+		body: normalizedTypeToMoveTypeSignatureBody(type),
+	};
+}
+
+function normalizedTypeToMoveTypeSignatureBody(
+	type: HaneulMoveNormalizedType,
+): OpenMoveTypeSignatureBody {
+	if (typeof type === 'string') {
+		switch (type) {
+			case 'Address':
+				return 'address';
+			case 'Bool':
+				return 'bool';
+			case 'U8':
+				return 'u8';
+			case 'U16':
+				return 'u16';
+			case 'U32':
+				return 'u32';
+			case 'U64':
+				return 'u64';
+			case 'U128':
+				return 'u128';
+			case 'U256':
+				return 'u256';
+			default:
+				throw new Error(`Unexpected type ${type}`);
+		}
+	}
+
+	if ('Vector' in type) {
+		return { vector: normalizedTypeToMoveTypeSignatureBody(type.Vector) };
+	}
+
+	if ('Struct' in type) {
+		return {
+			datatype: {
+				package: type.Struct.address,
+				module: type.Struct.module,
+				type: type.Struct.name,
+				typeParameters: type.Struct.typeArguments.map(normalizedTypeToMoveTypeSignatureBody),
+			},
+		};
+	}
+
+	if ('TypeParameter' in type) {
+		return { typeParameter: type.TypeParameter };
+	}
+
+	throw new Error(`Unexpected type ${JSON.stringify(type)}`);
+}
+
+export function pureBcsSchemaFromOpenMoveTypeSignatureBody(
+	typeSignature: OpenMoveTypeSignatureBody,
+): BcsType<any> {
+	if (typeof typeSignature === 'string') {
+		switch (typeSignature) {
+			case 'address':
+				return bcs.Address;
+			case 'bool':
+				return bcs.Bool;
+			case 'u8':
+				return bcs.U8;
+			case 'u16':
+				return bcs.U16;
+			case 'u32':
+				return bcs.U32;
+			case 'u64':
+				return bcs.U64;
+			case 'u128':
+				return bcs.U128;
+			case 'u256':
+				return bcs.U256;
+			default:
+				throw new Error(`Unknown type signature ${typeSignature}`);
+		}
+	}
+
+	if ('vector' in typeSignature) {
+		return bcs.vector(pureBcsSchemaFromOpenMoveTypeSignatureBody(typeSignature.vector));
+	}
+
+	throw new Error(`Expected pure typeSignature, but got ${JSON.stringify(typeSignature)}`);
+}

package/src/transactions/utils.ts

@@ -0,0 +1,142 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { is } from 'valibot';
+
+import type { HaneulMoveNormalizedType } from '../client/index.js';
+import { normalizeHaneulAddress } from '../utils/haneul-types.js';
+import { ArgumentSchema } from './data/internal.js';
+import type { Argument, CallArg, Command } from './data/internal.js';
+
+export function extractMutableReference(
+	normalizedType: HaneulMoveNormalizedType,
+): HaneulMoveNormalizedType | undefined {
+	return typeof normalizedType === 'object' && 'MutableReference' in normalizedType
+		? normalizedType.MutableReference
+		: undefined;
+}
+
+export function extractReference(
+	normalizedType: HaneulMoveNormalizedType,
+): HaneulMoveNormalizedType | undefined {
+	return typeof normalizedType === 'object' && 'Reference' in normalizedType
+		? normalizedType.Reference
+		: undefined;
+}
+
+export function extractStructTag(
+	normalizedType: HaneulMoveNormalizedType,
+): Extract<HaneulMoveNormalizedType, { Struct: unknown }> | undefined {
+	if (typeof normalizedType === 'object' && 'Struct' in normalizedType) {
+		return normalizedType;
+	}
+
+	const ref = extractReference(normalizedType);
+	const mutRef = extractMutableReference(normalizedType);
+
+	if (typeof ref === 'object' && 'Struct' in ref) {
+		return ref;
+	}
+
+	if (typeof mutRef === 'object' && 'Struct' in mutRef) {
+		return mutRef;
+	}
+	return undefined;
+}
+
+export function getIdFromCallArg(arg: string | CallArg) {
+	if (typeof arg === 'string') {
+		return normalizeHaneulAddress(arg);
+	}
+
+	if (arg.Object) {
+		if (arg.Object.ImmOrOwnedObject) {
+			return normalizeHaneulAddress(arg.Object.ImmOrOwnedObject.objectId);
+		}
+
+		if (arg.Object.Receiving) {
+			return normalizeHaneulAddress(arg.Object.Receiving.objectId);
+		}
+
+		return normalizeHaneulAddress(arg.Object.SharedObject.objectId);
+	}
+
+	if (arg.UnresolvedObject) {
+		return normalizeHaneulAddress(arg.UnresolvedObject.objectId);
+	}
+
+	return undefined;
+}
+
+export function isArgument(value: unknown): value is Argument {
+	return is(ArgumentSchema, value);
+}
+
+export function remapCommandArguments(
+	command: Command,
+	inputMapping: Map<number, number>,
+	commandMapping: Map<number, number>,
+) {
+	const remapArg = (arg: Argument): Argument => {
+		switch (arg.$kind) {
+			case 'Input': {
+				const newInputIndex = inputMapping.get(arg.Input);
+				if (newInputIndex === undefined) {
+					throw new Error(`Input ${arg.Input} not found in input mapping`);
+				}
+				return { ...arg, Input: newInputIndex };
+			}
+			case 'Result': {
+				const newCommandIndex = commandMapping.get(arg.Result);
+				if (newCommandIndex !== undefined) {
+					return { ...arg, Result: newCommandIndex };
+				}
+				return arg;
+			}
+			case 'NestedResult': {
+				const newCommandIndex = commandMapping.get(arg.NestedResult[0]);
+				if (newCommandIndex !== undefined) {
+					return { ...arg, NestedResult: [newCommandIndex, arg.NestedResult[1]] };
+				}
+				return arg;
+			}
+			default:
+				return arg;
+		}
+	};
+
+	switch (command.$kind) {
+		case 'MoveCall':
+			command.MoveCall.arguments = command.MoveCall.arguments.map(remapArg);
+			break;
+		case 'TransferObjects':
+			command.TransferObjects.objects = command.TransferObjects.objects.map(remapArg);
+			command.TransferObjects.address = remapArg(command.TransferObjects.address);
+			break;
+		case 'SplitCoins':
+			command.SplitCoins.coin = remapArg(command.SplitCoins.coin);
+			command.SplitCoins.amounts = command.SplitCoins.amounts.map(remapArg);
+			break;
+		case 'MergeCoins':
+			command.MergeCoins.destination = remapArg(command.MergeCoins.destination);
+			command.MergeCoins.sources = command.MergeCoins.sources.map(remapArg);
+			break;
+		case 'MakeMoveVec':
+			command.MakeMoveVec.elements = command.MakeMoveVec.elements.map(remapArg);
+			break;
+		case 'Upgrade':
+			command.Upgrade.ticket = remapArg(command.Upgrade.ticket);
+			break;
+		case '$Intent': {
+			const inputs = command.$Intent.inputs;
+			command.$Intent.inputs = {};
+
+			for (const [key, value] of Object.entries(inputs)) {
+				command.$Intent.inputs[key] = Array.isArray(value) ? value.map(remapArg) : remapArg(value);
+			}
+			break;
+		}
+		case 'Publish':
+			break;
+	}
+}

package/src/utils/constants.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { normalizeHaneulObjectId } from './haneul-types.js';
+
+export const HANEUL_DECIMALS = 9;
+export const GEUNHWA_PER_HANEUL = BigInt(1000000000);
+
+export const MOVE_STDLIB_ADDRESS = '0x1';
+export const HANEUL_FRAMEWORK_ADDRESS = '0x2';
+export const HANEUL_SYSTEM_ADDRESS = '0x3';
+export const HANEUL_CLOCK_OBJECT_ID = normalizeHaneulObjectId('0x6');
+export const HANEUL_SYSTEM_MODULE_NAME = 'haneul_system';
+export const HANEUL_TYPE_ARG = `${HANEUL_FRAMEWORK_ADDRESS}::haneul::HANEUL`;
+export const HANEUL_SYSTEM_STATE_OBJECT_ID: string = normalizeHaneulObjectId('0x5');
+export const HANEUL_RANDOM_OBJECT_ID = normalizeHaneulObjectId('0x8');

package/src/utils/derived-objects.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { TypeTag } from '../bcs/bcs.js';
+import { TypeTagSerializer } from '../bcs/type-tag-serializer.js';
+import { deriveDynamicFieldID } from './dynamic-fields.js';
+
+/**
+ * Derive the ID of an object that has been created through `derived_object`.
+ */
+export function deriveObjectID(
+	parentId: string,
+	typeTag: typeof TypeTag.$inferInput,
+	key: Uint8Array,
+) {
+	const typeTagStr = typeof typeTag === 'string' ? typeTag : TypeTagSerializer.tagToString(typeTag);
+	return deriveDynamicFieldID(
+		parentId,
+		`0x2::derived_object::DerivedObjectKey<${typeTagStr}>`,
+		key,
+	);
+}

package/src/utils/dynamic-fields.ts

@@ -0,0 +1,30 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { toHex } from '@haneullabs/bcs';
+import { blake2b } from '@noble/hashes/blake2b';
+
+import type { TypeTag } from '../bcs/bcs.js';
+import { bcs } from '../bcs/index.js';
+
+export function deriveDynamicFieldID(
+	parentId: string,
+	typeTag: typeof TypeTag.$inferInput,
+	key: Uint8Array,
+) {
+	const address = bcs.Address.serialize(parentId).toBytes();
+	const tag = bcs.TypeTag.serialize(typeTag).toBytes();
+	const keyLength = bcs.u64().serialize(key.length).toBytes();
+
+	const hash = blake2b.create({
+		dkLen: 32,
+	});
+
+	hash.update(new Uint8Array([0xf0]));
+	hash.update(address);
+	hash.update(keyLength);
+	hash.update(key);
+	hash.update(tag);
+
+	return `0x${toHex(hash.digest().slice(0, 32))}`;
+}

package/src/utils/format.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+const ELLIPSIS = '\u{2026}';
+
+export function formatAddress(address: string) {
+	if (address.length <= 6) {
+		return address;
+	}
+
+	const offset = address.startsWith('0x') ? 2 : 0;
+
+	return `0x${address.slice(offset, offset + 4)}${ELLIPSIS}${address.slice(-4)}`;
+}
+
+export function formatDigest(digest: string) {
+	// Use 10 first characters
+	return `${digest.slice(0, 10)}${ELLIPSIS}`;
+}

package/src/utils/haneul-types.ts

@@ -0,0 +1,114 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase58, splitGenericParameters } from '@haneullabs/bcs';
+
+import { isValidNamedPackage } from './move-registry.js';
+
+const TX_DIGEST_LENGTH = 32;
+
+/** Returns whether the tx digest is valid based on the serialization format */
+export function isValidTransactionDigest(value: string): value is string {
+	try {
+		const buffer = fromBase58(value);
+		return buffer.length === TX_DIGEST_LENGTH;
+	} catch {
+		return false;
+	}
+}
+
+// TODO - can we automatically sync this with rust length definition?
+// Source of truth is
+// https://github.com/GeunhwaJeong/haneul/blob/acb2b97ae21f47600e05b0d28127d88d0725561d/crate./haneul-types/src/base_types.rs#L67
+// which uses the Move account address length
+// https://github.com/move-language/move/blob/67ec40dc50c66c34fd73512fcc412f3b68d67235/language/move-core/types/src/account_address.rs#L23 .
+
+export const HANEUL_ADDRESS_LENGTH = 32;
+export function isValidHaneulAddress(value: string): value is string {
+	return isHex(value) && getHexByteLength(value) === HANEUL_ADDRESS_LENGTH;
+}
+
+export function isValidHaneulObjectId(value: string): boolean {
+	return isValidHaneulAddress(value);
+}
+
+export type StructTag = {
+	address: string;
+	module: string;
+	name: string;
+	typeParams: (string | StructTag)[];
+};
+
+function parseTypeTag(type: string): string | StructTag {
+	if (!type.includes('::')) return type;
+
+	return parseStructTag(type);
+}
+
+export function parseStructTag(type: string): StructTag {
+	const [address, module] = type.split('::');
+
+	const isMvrPackage = isValidNamedPackage(address);
+
+	const rest = type.slice(address.length + module.length + 4);
+	const name = rest.includes('<') ? rest.slice(0, rest.indexOf('<')) : rest;
+	const typeParams = rest.includes('<')
+		? splitGenericParameters(rest.slice(rest.indexOf('<') + 1, rest.lastIndexOf('>'))).map(
+				(typeParam) => parseTypeTag(typeParam.trim()),
+			)
+		: [];
+
+	return {
+		address: isMvrPackage ? address : normalizeHaneulAddress(address),
+		module,
+		name,
+		typeParams,
+	};
+}
+
+export function normalizeStructTag(type: string | StructTag): string {
+	const { address, module, name, typeParams } =
+		typeof type === 'string' ? parseStructTag(type) : type;
+
+	const formattedTypeParams =
+		typeParams?.length > 0
+			? `<${typeParams
+					.map((typeParam) =>
+						typeof typeParam === 'string' ? typeParam : normalizeStructTag(typeParam),
+					)
+					.join(',')}>`
+			: '';
+
+	return `${address}::${module}::${name}${formattedTypeParams}`;
+}
+
+/**
+ * Perform the following operations:
+ * 1. Make the address lower case
+ * 2. Prepend `0x` if the string does not start with `0x`.
+ * 3. Add more zeros if the length of the address(excluding `0x`) is less than `HANEUL_ADDRESS_LENGTH`
+ *
+ * WARNING: if the address value itself starts with `0x`, e.g., `0x0x`, the default behavior
+ * is to treat the first `0x` not as part of the address. The default behavior can be overridden by
+ * setting `forceAdd0x` to true
+ *
+ */
+export function normalizeHaneulAddress(value: string, forceAdd0x: boolean = false): string {
+	let address = value.toLowerCase();
+	if (!forceAdd0x && address.startsWith('0x')) {
+		address = address.slice(2);
+	}
+	return `0x${address.padStart(HANEUL_ADDRESS_LENGTH * 2, '0')}`;
+}
+
+export function normalizeHaneulObjectId(value: string, forceAdd0x: boolean = false): string {
+	return normalizeHaneulAddress(value, forceAdd0x);
+}
+
+function isHex(value: string): boolean {
+	return /^(0x|0X)?[a-fA-F0-9]+$/.test(value) && value.length % 2 === 0;
+}
+
+function getHexByteLength(value: string): number {
+	return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2;
+}