@haneullabs/haneul 0.1.0

package/src/transactions/Commands.ts

@@ -0,0 +1,184 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { toBase64 } from '@haneullabs/bcs';
+import type { InferInput } from 'valibot';
+import { parse } from 'valibot';
+
+import { normalizeHaneulObjectId } from '../utils/haneul-types.js';
+import type { Argument, CallArg, Command } from './data/internal.js';
+import { ArgumentSchema } from './data/internal.js';
+import type { AsyncTransactionThunk, Transaction } from './Transaction.js';
+
+export type TransactionArgument =
+	| InferInput<typeof ArgumentSchema>
+	| ((tx: Transaction) => InferInput<typeof ArgumentSchema>)
+	| AsyncTransactionThunk;
+export type TransactionInput = CallArg;
+
+// Keep in sync with constants in
+// crates/sui-framework/packages/sui-framework/sources/package.move
+export enum UpgradePolicy {
+	COMPATIBLE = 0,
+	ADDITIVE = 128,
+	DEP_ONLY = 192,
+}
+
+type TransactionShape<T extends Command['$kind']> = { $kind: T } & {
+	[K in T]: Extract<Command, { [K in T]: any }>[T];
+};
+
+/**
+ * Simple helpers used to construct transactions:
+ */
+export const Commands = {
+	MoveCall(
+		input:
+			| {
+					package: string;
+					module: string;
+					function: string;
+					arguments?: Argument[];
+					typeArguments?: string[];
+			  }
+			| {
+					target: string;
+					arguments?: Argument[];
+					typeArguments?: string[];
+			  },
+	): TransactionShape<'MoveCall'> {
+		const [pkg, mod = '', fn = ''] =
+			'target' in input ? input.target.split('::') : [input.package, input.module, input.function];
+
+		return {
+			$kind: 'MoveCall',
+			MoveCall: {
+				package: pkg,
+				module: mod,
+				function: fn,
+				typeArguments: input.typeArguments ?? [],
+				arguments: input.arguments ?? [],
+			},
+		};
+	},
+
+	TransferObjects(
+		objects: InferInput<typeof ArgumentSchema>[],
+		address: InferInput<typeof ArgumentSchema>,
+	): TransactionShape<'TransferObjects'> {
+		return {
+			$kind: 'TransferObjects',
+			TransferObjects: {
+				objects: objects.map((o) => parse(ArgumentSchema, o)),
+				address: parse(ArgumentSchema, address),
+			},
+		};
+	},
+	SplitCoins(
+		coin: InferInput<typeof ArgumentSchema>,
+		amounts: InferInput<typeof ArgumentSchema>[],
+	): TransactionShape<'SplitCoins'> {
+		return {
+			$kind: 'SplitCoins',
+			SplitCoins: {
+				coin: parse(ArgumentSchema, coin),
+				amounts: amounts.map((o) => parse(ArgumentSchema, o)),
+			},
+		};
+	},
+	MergeCoins(
+		destination: InferInput<typeof ArgumentSchema>,
+		sources: InferInput<typeof ArgumentSchema>[],
+	): TransactionShape<'MergeCoins'> {
+		return {
+			$kind: 'MergeCoins',
+			MergeCoins: {
+				destination: parse(ArgumentSchema, destination),
+				sources: sources.map((o) => parse(ArgumentSchema, o)),
+			},
+		};
+	},
+	Publish({
+		modules,
+		dependencies,
+	}: {
+		modules: number[][] | string[];
+		dependencies: string[];
+	}): TransactionShape<'Publish'> {
+		return {
+			$kind: 'Publish',
+			Publish: {
+				modules: modules.map((module) =>
+					typeof module === 'string' ? module : toBase64(new Uint8Array(module)),
+				),
+				dependencies: dependencies.map((dep) => normalizeHaneulObjectId(dep)),
+			},
+		};
+	},
+	Upgrade({
+		modules,
+		dependencies,
+		package: packageId,
+		ticket,
+	}: {
+		modules: number[][] | string[];
+		dependencies: string[];
+		package: string;
+		ticket: InferInput<typeof ArgumentSchema>;
+	}): TransactionShape<'Upgrade'> {
+		return {
+			$kind: 'Upgrade',
+			Upgrade: {
+				modules: modules.map((module) =>
+					typeof module === 'string' ? module : toBase64(new Uint8Array(module)),
+				),
+				dependencies: dependencies.map((dep) => normalizeHaneulObjectId(dep)),
+				package: packageId,
+				ticket: parse(ArgumentSchema, ticket),
+			},
+		};
+	},
+	MakeMoveVec({
+		type,
+		elements,
+	}: {
+		type?: string;
+		elements: InferInput<typeof ArgumentSchema>[];
+	}): TransactionShape<'MakeMoveVec'> {
+		return {
+			$kind: 'MakeMoveVec',
+			MakeMoveVec: {
+				type: type ?? null,
+				elements: elements.map((o) => parse(ArgumentSchema, o)),
+			},
+		};
+	},
+	Intent({
+		name,
+		inputs = {},
+		data = {},
+	}: {
+		name: string;
+		inputs?: Record<
+			string,
+			InferInput<typeof ArgumentSchema> | InferInput<typeof ArgumentSchema>[]
+		>;
+		data?: Record<string, unknown>;
+	}): TransactionShape<'$Intent'> {
+		return {
+			$kind: '$Intent',
+			$Intent: {
+				name,
+				inputs: Object.fromEntries(
+					Object.entries(inputs).map(([key, value]) => [
+						key,
+						Array.isArray(value)
+							? value.map((o) => parse(ArgumentSchema, o))
+							: parse(ArgumentSchema, value),
+					]),
+				),
+				data,
+			},
+		};
+	},
+};

package/src/transactions/Inputs.ts

@@ -0,0 +1,68 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+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';
+
+function Pure(data: Uint8Array | SerializedBcs<any>): Extract<CallArg, { Pure: unknown }> {
+	return {
+		$kind: 'Pure',
+		Pure: {
+			bytes: data instanceof Uint8Array ? toBase64(data) : data.toBase64(),
+		},
+	};
+}
+
+export const Inputs = {
+	Pure,
+	ObjectRef({ objectId, digest, version }: ObjectRef): Extract<CallArg, { Object: unknown }> {
+		return {
+			$kind: 'Object',
+			Object: {
+				$kind: 'ImmOrOwnedObject',
+				ImmOrOwnedObject: {
+					digest,
+					version,
+					objectId: normalizeHaneulAddress(objectId),
+				},
+			},
+		};
+	},
+	SharedObjectRef({
+		objectId,
+		mutable,
+		initialSharedVersion,
+	}: {
+		objectId: string;
+		mutable: boolean;
+		initialSharedVersion: number | string;
+	}): Extract<CallArg, { Object: unknown }> {
+		return {
+			$kind: 'Object',
+			Object: {
+				$kind: 'SharedObject',
+				SharedObject: {
+					mutable,
+					initialSharedVersion,
+					objectId: normalizeHaneulAddress(objectId),
+				},
+			},
+		};
+	},
+	ReceivingRef({ objectId, digest, version }: ObjectRef): Extract<CallArg, { Object: unknown }> {
+		return {
+			$kind: 'Object',
+			Object: {
+				$kind: 'Receiving',
+				Receiving: {
+					digest,
+					version,
+					objectId: normalizeHaneulAddress(objectId),
+				},
+			},
+		};
+	},
+};

package/src/transactions/ObjectCache.ts

@@ -0,0 +1,300 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { bcs } from '../bcs/index.js';
+import { normalizeHaneulAddress } from '../utils/haneul-types.js';
+import type { OpenMoveTypeSignature } from './data/internal.js';
+import type { TransactionPlugin } from './resolve.js';
+
+export interface ObjectCacheEntry {
+	objectId: string;
+	version: string;
+	digest: string;
+	owner: string | null;
+	initialSharedVersion: string | null;
+}
+
+export interface MoveFunctionCacheEntry {
+	package: string;
+	module: string;
+	function: string;
+	parameters: OpenMoveTypeSignature[];
+}
+
+export interface CacheEntryTypes {
+	OwnedObject: ObjectCacheEntry;
+	SharedOrImmutableObject: ObjectCacheEntry;
+	MoveFunction: MoveFunctionCacheEntry;
+	Custom: unknown;
+}
+export abstract class AsyncCache {
+	protected abstract get<T extends keyof CacheEntryTypes>(
+		type: T,
+		key: string,
+	): Promise<CacheEntryTypes[T] | null>;
+	protected abstract set<T extends keyof CacheEntryTypes>(
+		type: T,
+		key: string,
+		value: CacheEntryTypes[T],
+	): Promise<void>;
+	protected abstract delete<T extends keyof CacheEntryTypes>(type: T, key: string): Promise<void>;
+	abstract clear<T extends keyof CacheEntryTypes>(type?: T): Promise<void>;
+
+	async getObject(id: string) {
+		const [owned, shared] = await Promise.all([
+			this.get('OwnedObject', id),
+			this.get('SharedOrImmutableObject', id),
+		]);
+
+		return owned ?? shared ?? null;
+	}
+
+	async getObjects(ids: string[]) {
+		return Promise.all(ids.map((id) => this.getObject(id)));
+	}
+
+	async addObject(object: ObjectCacheEntry) {
+		if (object.owner) {
+			await this.set('OwnedObject', object.objectId, object);
+		} else {
+			await this.set('SharedOrImmutableObject', object.objectId, object);
+		}
+
+		return object;
+	}
+
+	async addObjects(objects: ObjectCacheEntry[]) {
+		await Promise.all(objects.map(async (object) => this.addObject(object)));
+	}
+
+	async deleteObject(id: string) {
+		await Promise.all([this.delete('OwnedObject', id), this.delete('SharedOrImmutableObject', id)]);
+	}
+
+	async deleteObjects(ids: string[]) {
+		await Promise.all(ids.map((id) => this.deleteObject(id)));
+	}
+
+	async getMoveFunctionDefinition(ref: { package: string; module: string; function: string }) {
+		const functionName = `${normalizeHaneulAddress(ref.package)}::${ref.module}::${ref.function}`;
+		return this.get('MoveFunction', functionName);
+	}
+
+	async addMoveFunctionDefinition(functionEntry: MoveFunctionCacheEntry) {
+		const pkg = normalizeHaneulAddress(functionEntry.package);
+		const functionName = `${pkg}::${functionEntry.module}::${functionEntry.function}`;
+		const entry = {
+			...functionEntry,
+			package: pkg,
+		};
+
+		await this.set('MoveFunction', functionName, entry);
+
+		return entry;
+	}
+
+	async deleteMoveFunctionDefinition(ref: { package: string; module: string; function: string }) {
+		const functionName = `${normalizeHaneulAddress(ref.package)}::${ref.module}::${ref.function}`;
+		await this.delete('MoveFunction', functionName);
+	}
+
+	async getCustom<T>(key: string) {
+		return this.get('Custom', key) as Promise<T | null>;
+	}
+
+	async setCustom<T>(key: string, value: T) {
+		return this.set('Custom', key, value);
+	}
+
+	async deleteCustom(key: string) {
+		return this.delete('Custom', key);
+	}
+}
+
+export class InMemoryCache extends AsyncCache {
+	#caches = {
+		OwnedObject: new Map<string, ObjectCacheEntry>(),
+		SharedOrImmutableObject: new Map<string, ObjectCacheEntry>(),
+		MoveFunction: new Map<string, MoveFunctionCacheEntry>(),
+		Custom: new Map<string, unknown>(),
+	};
+
+	protected async get<T extends keyof CacheEntryTypes>(type: T, key: string) {
+		return (this.#caches[type].get(key) as CacheEntryTypes[T]) ?? null;
+	}
+
+	protected async set<T extends keyof CacheEntryTypes>(
+		type: T,
+		key: string,
+		value: CacheEntryTypes[T],
+	) {
+		(this.#caches[type] as Map<string, typeof value>).set(key, value as never);
+	}
+
+	protected async delete<T extends keyof CacheEntryTypes>(type: T, key: string) {
+		this.#caches[type].delete(key);
+	}
+
+	async clear<T extends keyof CacheEntryTypes>(type?: T) {
+		if (type) {
+			this.#caches[type].clear();
+		} else {
+			for (const cache of Object.values(this.#caches)) {
+				cache.clear();
+			}
+		}
+	}
+}
+
+export interface ObjectCacheOptions {
+	cache?: AsyncCache;
+	onEffects?: (effects: typeof bcs.TransactionEffects.$inferType) => Promise<void>;
+}
+
+export class ObjectCache {
+	#cache: AsyncCache;
+	#onEffects?: (effects: typeof bcs.TransactionEffects.$inferType) => Promise<void>;
+
+	constructor({ cache = new InMemoryCache(), onEffects }: ObjectCacheOptions) {
+		this.#cache = cache;
+		this.#onEffects = onEffects;
+	}
+
+	asPlugin(): TransactionPlugin {
+		return async (transactionData, _options, next) => {
+			const unresolvedObjects = transactionData.inputs
+				.filter((input) => input.UnresolvedObject)
+				.map((input) => input.UnresolvedObject!.objectId);
+
+			const cached = (await this.#cache.getObjects(unresolvedObjects)).filter(
+				(obj) => obj !== null,
+			);
+
+			const byId = new Map(cached.map((obj) => [obj!.objectId, obj]));
+
+			for (const input of transactionData.inputs) {
+				if (!input.UnresolvedObject) {
+					continue;
+				}
+
+				const cached = byId.get(input.UnresolvedObject.objectId);
+
+				if (!cached) {
+					continue;
+				}
+
+				if (cached.initialSharedVersion && !input.UnresolvedObject.initialSharedVersion) {
+					input.UnresolvedObject.initialSharedVersion = cached.initialSharedVersion;
+				} else {
+					if (cached.version && !input.UnresolvedObject.version) {
+						input.UnresolvedObject.version = cached.version;
+					}
+
+					if (cached.digest && !input.UnresolvedObject.digest) {
+						input.UnresolvedObject.digest = cached.digest;
+					}
+				}
+			}
+
+			await Promise.all(
+				transactionData.commands.map(async (commands) => {
+					if (commands.MoveCall) {
+						const def = await this.getMoveFunctionDefinition({
+							package: commands.MoveCall.package,
+							module: commands.MoveCall.module,
+							function: commands.MoveCall.function,
+						});
+
+						if (def) {
+							commands.MoveCall._argumentTypes = def.parameters;
+						}
+					}
+				}),
+			);
+
+			await next();
+
+			await Promise.all(
+				transactionData.commands.map(async (commands) => {
+					if (commands.MoveCall?._argumentTypes) {
+						await this.#cache.addMoveFunctionDefinition({
+							package: commands.MoveCall.package,
+							module: commands.MoveCall.module,
+							function: commands.MoveCall.function,
+							parameters: commands.MoveCall._argumentTypes,
+						});
+					}
+				}),
+			);
+		};
+	}
+
+	async clear() {
+		await this.#cache.clear();
+	}
+
+	async getMoveFunctionDefinition(ref: { package: string; module: string; function: string }) {
+		return this.#cache.getMoveFunctionDefinition(ref);
+	}
+
+	async getObjects(ids: string[]) {
+		return this.#cache.getObjects(ids);
+	}
+
+	async deleteObjects(ids: string[]) {
+		return this.#cache.deleteObjects(ids);
+	}
+
+	async clearOwnedObjects() {
+		await this.#cache.clear('OwnedObject');
+	}
+
+	async clearCustom() {
+		await this.#cache.clear('Custom');
+	}
+
+	async getCustom<T>(key: string) {
+		return this.#cache.getCustom<T>(key);
+	}
+
+	async setCustom<T>(key: string, value: T) {
+		return this.#cache.setCustom(key, value);
+	}
+
+	async deleteCustom(key: string) {
+		return this.#cache.deleteCustom(key);
+	}
+
+	async applyEffects(effects: typeof bcs.TransactionEffects.$inferType) {
+		if (!effects.V2) {
+			throw new Error(`Unsupported transaction effects version ${effects.$kind}`);
+		}
+
+		const { lamportVersion, changedObjects } = effects.V2;
+
+		const deletedIds: string[] = [];
+		const addedObjects: ObjectCacheEntry[] = [];
+
+		changedObjects.forEach(([id, change]) => {
+			if (change.outputState.NotExist) {
+				deletedIds.push(id);
+			} else if (change.outputState.ObjectWrite) {
+				const [digest, owner] = change.outputState.ObjectWrite;
+
+				addedObjects.push({
+					objectId: id,
+					digest,
+					version: lamportVersion,
+					owner: owner.AddressOwner ?? owner.ObjectOwner ?? null,
+					initialSharedVersion: owner.Shared?.initialSharedVersion ?? null,
+				});
+			}
+		});
+
+		await Promise.all([
+			this.#cache.addObjects(addedObjects),
+			this.#cache.deleteObjects(deletedIds),
+			this.#onEffects?.(effects),
+		]);
+	}
+}