@haneullabs/haneul 0.1.0 → 2.5.0

package/src/transactions/data/internal.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { EnumInputShape, EnumOutputShape } from '@haneullabs/bcs';
-import type { GenericSchema, InferInput, InferOutput } from 'valibot';
+import type { GenericSchema, InferInput, InferOutput, ObjectEntries, ObjectSchema } from 'valibot';
 import {
 	array,
 	boolean,
@@ -26,6 +26,7 @@ import {
 
 import { isValidHaneulAddress, normalizeHaneulAddress } from '../../utils/haneul-types.js';
 import type { Simplify } from '@haneullabs/utils';
+import type { HaneulClientTypes } from '../../client/types.js';
 
 type EnumSchemaInput<T extends Record<string, GenericSchema<any>>> = EnumInputShape<
 	Simplify<{
@@ -45,20 +46,35 @@ type EnumSchema<T extends Record<string, GenericSchema<any>>> = GenericSchema<
 >;
 
 export function safeEnum<T extends Record<string, GenericSchema<any>>>(options: T): EnumSchema<T> {
-	const unionOptions = Object.entries(options).map(([key, value]) => object({ [key]: value }));
-
-	return pipe(
-		union(unionOptions),
-		transform(
-			(value) =>
-				({
-					...value,
-					$kind: Object.keys(value)[0] as keyof typeof value,
-				}) as EnumSchemaOutput<T>,
+	return union(
+		Object.keys(options).map(
+			(key) =>
+				withKind(
+					key,
+					object({
+						[key]: options[key],
+					}),
+				) as GenericSchema<EnumOutputShape<T>>,
 		),
 	) as EnumSchema<T>;
 }
 
+function withKind<K extends string, TEntries extends ObjectEntries>(
+	key: K,
+	schema: ObjectSchema<TEntries, undefined>,
+) {
+	return pipe(
+		object({
+			...schema.entries,
+			$kind: optional(literal(key)),
+		}),
+		transform((value) => ({ ...value, $kind: key })),
+	) as GenericSchema<
+		Simplify<InferInput<ObjectSchema<TEntries, undefined>> & { $kind?: K }>,
+		Simplify<InferOutput<ObjectSchema<TEntries, undefined>> & { $kind: K }>
+	>;
+}
+
 export const HaneulAddress = pipe(
 	string(),
 	transform((value) => normalizeHaneulAddress(value)),
@@ -78,6 +94,13 @@ export const JsonU64 = pipe(
 		}
 	}, 'Invalid u64'),
 );
+
+export const U32 = pipe(
+	number(),
+	integer(),
+	check((val) => val >= 0 && val < 2 ** 32, 'Invalid u32'),
+);
+
 // https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/base_types.rs#L138
 // Implemented as a tuple in rust
 export const ObjectRefSchema = object({
@@ -88,32 +111,21 @@ export const ObjectRefSchema = object({
 export type ObjectRef = InferOutput<typeof ObjectRefSchema>;
 
 // https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L690-L702
-export const ArgumentSchema = pipe(
-	union([
-		object({ GasCoin: literal(true) }),
-		object({ Input: pipe(number(), integer()), type: optional(literal('pure')) }),
-		object({ Input: pipe(number(), integer()), type: optional(literal('object')) }),
-		object({ Result: pipe(number(), integer()) }),
+export const ArgumentSchema = union([
+	withKind('GasCoin', object({ GasCoin: literal(true) })),
+	withKind(
+		'Input',
+		object({
+			Input: pipe(number(), integer()),
+			type: optional(union([literal('pure'), literal('object'), literal('withdrawal')])),
+		}),
+	),
+	withKind('Result', object({ Result: pipe(number(), integer()) })),
+	withKind(
+		'NestedResult',
 		object({ NestedResult: tuple([pipe(number(), integer()), pipe(number(), integer())]) }),
-	]),
-	transform((value) => ({
-		...value,
-		$kind: Object.keys(value)[0] as keyof typeof value,
-	})),
-	// Defined manually to add `type?: 'pure' | 'object'` to Input
-) as GenericSchema<
-	// Input
-	| { GasCoin: true }
-	| { Input: number; type?: 'pure' | 'object' }
-	| { Result: number }
-	| { NestedResult: [number, number] },
-	// Output
-	| { $kind: 'GasCoin'; GasCoin: true }
-	| { $kind: 'Input'; Input: number; type?: 'pure' }
-	| { $kind: 'Input'; Input: number; type?: 'object' }
-	| { $kind: 'Result'; Result: number }
-	| { $kind: 'NestedResult'; NestedResult: [number, number] }
->;
+	),
+]);
 
 export type Argument = InferOutput<typeof ArgumentSchema>;
 
@@ -136,54 +148,31 @@ export const StructTagSchema = object({
 });
 export type StructTag = InferOutput<typeof StructTagSchema>;
 
-// https://github.com/GeunhwaJeong/haneul/blob/cea8742e810142a8145fd83c4c142d61e561004a/crates/sui-graphql-rpc/schema/current_progress_schema.graphql#L1614-L1627
-export type OpenMoveTypeSignatureBody =
-	| 'address'
-	| 'bool'
-	| 'u8'
-	| 'u16'
-	| 'u32'
-	| 'u64'
-	| 'u128'
-	| 'u256'
-	| { vector: OpenMoveTypeSignatureBody }
-	| {
-			datatype: {
-				package: string;
-				module: string;
-				type: string;
-				typeParameters: OpenMoveTypeSignatureBody[];
-			};
-	  }
-	| { typeParameter: number };
-
-export const OpenMoveTypeSignatureBodySchema: GenericSchema<OpenMoveTypeSignatureBody> = union([
-	literal('address'),
-	literal('bool'),
-	literal('u8'),
-	literal('u16'),
-	literal('u32'),
-	literal('u64'),
-	literal('u128'),
-	literal('u256'),
-	object({ vector: lazy(() => OpenMoveTypeSignatureBodySchema) }),
+export const OpenSignatureBodySchema: GenericSchema<HaneulClientTypes.OpenSignatureBody> = union([
+	object({ $kind: literal('address') }),
+	object({ $kind: literal('bool') }),
+	object({ $kind: literal('u8') }),
+	object({ $kind: literal('u16') }),
+	object({ $kind: literal('u32') }),
+	object({ $kind: literal('u64') }),
+	object({ $kind: literal('u128') }),
+	object({ $kind: literal('u256') }),
+	object({ $kind: literal('unknown') }),
+	object({ $kind: literal('vector'), vector: lazy(() => OpenSignatureBodySchema) }),
 	object({
+		$kind: literal('datatype'),
 		datatype: object({
-			package: string(),
-			module: string(),
-			type: string(),
-			typeParameters: array(lazy(() => OpenMoveTypeSignatureBodySchema)),
+			typeName: string(),
+			typeParameters: array(lazy(() => OpenSignatureBodySchema)),
 		}),
 	}),
-	object({ typeParameter: pipe(number(), integer()) }),
+	object({ $kind: literal('typeParameter'), index: pipe(number(), integer()) }),
 ]);
 
-// https://github.com/GeunhwaJeong/haneul/blob/cea8742e810142a8145fd83c4c142d61e561004a/crates/sui-graphql-rpc/schema/current_progress_schema.graphql#L1609-L1612
-export const OpenMoveTypeSignatureSchema = object({
-	ref: nullable(union([literal('&'), literal('&mut')])),
-	body: OpenMoveTypeSignatureBodySchema,
+export const OpenSignatureSchema = object({
+	reference: nullable(union([literal('mutable'), literal('immutable'), literal('unknown')])),
+	body: OpenSignatureBodySchema,
 });
-export type OpenMoveTypeSignature = InferOutput<typeof OpenMoveTypeSignatureSchema>;
 
 // https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L707-L718
 const ProgrammableMoveCallSchema = object({
@@ -193,7 +182,7 @@ const ProgrammableMoveCallSchema = object({
 	// snake case in rust
 	typeArguments: array(string()),
 	arguments: array(ArgumentSchema),
-	_argumentTypes: optional(nullable(array(OpenMoveTypeSignatureSchema))),
+	_argumentTypes: optional(nullable(array(OpenSignatureSchema))),
 });
 export type ProgrammableMoveCall = InferOutput<typeof ProgrammableMoveCallSchema>;
 
@@ -242,7 +231,7 @@ export type Command<Arg = Argument> = EnumOutputShape<{
 		function: string;
 		typeArguments: string[];
 		arguments: Arg[];
-		_argumentTypes?: OpenMoveTypeSignature[] | null;
+		_argumentTypes?: HaneulClientTypes.OpenSignature[] | null;
 	};
 	TransferObjects: {
 		objects: Arg[];
@@ -289,6 +278,33 @@ export const ObjectArgSchema = safeEnum({
 	Receiving: ObjectRefSchema,
 });
 
+// Rust: crate./haneul-types/src/transaction.rs
+export const ReservationSchema = safeEnum({
+	MaxAmountU64: JsonU64,
+});
+export type Reservation = InferOutput<typeof ReservationSchema>;
+
+// Rust: crate./haneul-types/src/transaction.rs
+export const WithdrawalTypeArgSchema = safeEnum({
+	Balance: string(),
+});
+export type WithdrawalTypeArg = InferOutput<typeof WithdrawalTypeArgSchema>;
+
+// Rust: crate./haneul-types/src/transaction.rs
+export const WithdrawFromSchema = safeEnum({
+	Sender: literal(true),
+	Sponsor: literal(true),
+});
+export type WithdrawFrom = InferOutput<typeof WithdrawFromSchema>;
+
+// Rust: crate./haneul-types/src/transaction.rs
+export const FundsWithdrawalArgSchema = object({
+	reservation: ReservationSchema,
+	typeArg: WithdrawalTypeArgSchema,
+	withdrawFrom: WithdrawFromSchema,
+});
+export type FundsWithdrawalArg = InferOutput<typeof FundsWithdrawalArgSchema>;
+
 // https://github.com/GeunhwaJeong/haneul/blob/df41d5fa8127634ff4285671a01ead00e519f806/crate./haneul-types/src/transaction.rs#L75-L80
 const CallArgSchema = safeEnum({
 	Object: ObjectArgSchema,
@@ -305,6 +321,7 @@ const CallArgSchema = safeEnum({
 		initialSharedVersion: optional(nullable(JsonU64)),
 		mutable: optional(nullable(boolean())),
 	}),
+	FundsWithdrawal: FundsWithdrawalArgSchema,
 });
 export type CallArg = InferOutput<typeof CallArgSchema>;
 
@@ -315,9 +332,21 @@ export const NormalizedCallArg = safeEnum({
 	}),
 });
 
+// Rust: crate./haneul-types/src/transaction.rs
+export const ValidDuringSchema = object({
+	minEpoch: nullable(JsonU64),
+	maxEpoch: nullable(JsonU64),
+	minTimestamp: nullable(JsonU64),
+	maxTimestamp: nullable(JsonU64),
+	chain: string(),
+	nonce: U32,
+});
+export type ValidDuring = InferOutput<typeof ValidDuringSchema>;
+
 export const TransactionExpiration = safeEnum({
 	None: literal(true),
 	Epoch: JsonU64,
+	ValidDuring: ValidDuringSchema,
 });
 
 export type TransactionExpiration = InferOutput<typeof TransactionExpiration>;

package/src/transactions/data/v2.ts

@@ -21,7 +21,15 @@ import {
 	unknown,
 } from 'valibot';
 
-import { BCSBytes, JsonU64, ObjectID, ObjectRefSchema, HaneulAddress } from './internal.js';
+import {
+	BCSBytes,
+	FundsWithdrawalArgSchema,
+	JsonU64,
+	ObjectID,
+	ObjectRefSchema,
+	HaneulAddress,
+	ValidDuringSchema,
+} from './internal.js';
 import type { Simplify } from '@haneullabs/utils';
 
 function enumUnion<T extends Record<string, GenericSchema<any>>>(options: T) {
@@ -128,11 +136,13 @@ const CallArg = enumUnion({
 		initialSharedVersion: optional(nullable(JsonU64)),
 		mutable: optional(nullable(boolean())),
 	}),
+	FundsWithdrawal: FundsWithdrawalArgSchema,
 });
 
 const TransactionExpiration = enumUnion({
 	None: literal(true),
 	Epoch: JsonU64,
+	ValidDuring: ValidDuringSchema,
 });
 
 export const SerializedTransactionDataV2Schema = object({

package/src/transactions/executor/caching.ts

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { bcs } from '../../bcs/index.js';
-import type { ExecuteTransactionBlockParams, HaneulClient } from '../../client/index.js';
+import type { ClientWithCoreApi } from '../../client/core.js';
+import { coreClientResolveTransactionPlugin } from '../../client/core-resolver.js';
+import type { HaneulClientTypes } from '../../client/types.js';
 import type { Signer } from '../../cryptography/keypair.js';
 import type { BuildTransactionOptions } from '../resolve.js';
 import type { ObjectCacheOptions } from '../ObjectCache.js';
@@ -10,8 +12,14 @@ import { ObjectCache } from '../ObjectCache.js';
 import type { Transaction } from '../Transaction.js';
 import { isTransaction } from '../Transaction.js';
 
+export interface ExecuteTransactionOptions<Include extends HaneulClientTypes.TransactionInclude = {}> {
+	transaction: Transaction | Uint8Array;
+	signatures: string[];
+	include?: Include;
+}
+
 export class CachingTransactionExecutor {
-	#client: HaneulClient;
+	#client: ClientWithCoreApi;
 	#lastDigest: string | null = null;
 	cache: ObjectCache;
 
@@ -19,7 +27,7 @@ export class CachingTransactionExecutor {
 		client,
 		...options
 	}: ObjectCacheOptions & {
-		client: HaneulClient;
+		client: ClientWithCoreApi;
 	}) {
 		this.#client = client;
 		this.cache = new ObjectCache(options);
@@ -42,59 +50,59 @@ export class CachingTransactionExecutor {
 		...options
 	}: { transaction: Transaction } & BuildTransactionOptions) {
 		transaction.addBuildPlugin(this.cache.asPlugin());
+		transaction.addBuildPlugin(coreClientResolveTransactionPlugin);
 		return transaction.build({
 			client: this.#client,
 			...options,
 		});
 	}
 
-	async executeTransaction({
+	async executeTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>({
 		transaction,
-		options,
-		...input
-	}: {
-		transaction: Transaction | Uint8Array;
-	} & Omit<ExecuteTransactionBlockParams, 'transactionBlock'>) {
+		signatures,
+		include,
+	}: ExecuteTransactionOptions<Include>): Promise<
+		HaneulClientTypes.TransactionResult<Include & { effects: true }>
+	> {
 		const bytes = isTransaction(transaction)
 			? await this.buildTransaction({ transaction })
 			: transaction;
 
-		const results = await this.#client.executeTransactionBlock({
-			...input,
-			transactionBlock: bytes,
-			options: {
-				...options,
-				showRawEffects: true,
+		const results = await this.#client.core.executeTransaction({
+			transaction: bytes,
+			signatures,
+			include: {
+				...include,
+				effects: true,
 			},
 		});
 
-		if (results.rawEffects) {
-			const effects = bcs.TransactionEffects.parse(Uint8Array.from(results.rawEffects));
+		const tx = results.$kind === 'Transaction' ? results.Transaction : results.FailedTransaction;
+		if (tx.effects?.bcs) {
+			const effects = bcs.TransactionEffects.parse(tx.effects.bcs);
 			await this.applyEffects(effects);
 		}
 
-		return results;
+		return results as HaneulClientTypes.TransactionResult<Include & { effects: true }>;
 	}
 
-	async signAndExecuteTransaction({
-		options,
+	async signAndExecuteTransaction<Include extends HaneulClientTypes.TransactionInclude = {}>({
+		include,
 		transaction,
-		...input
+		signer,
 	}: {
 		transaction: Transaction;
-
 		signer: Signer;
-	} & Omit<ExecuteTransactionBlockParams, 'transactionBlock' | 'signature'>) {
-		transaction.setSenderIfNotSet(input.signer.toHaneulAddress());
+		include?: Include;
+	}): Promise<HaneulClientTypes.TransactionResult<Include & { effects: true }>> {
+		transaction.setSenderIfNotSet(signer.toHaneulAddress());
 		const bytes = await this.buildTransaction({ transaction });
-		const { signature } = await input.signer.signTransaction(bytes);
-		const results = await this.executeTransaction({
+		const { signature } = await signer.signTransaction(bytes);
+		return this.executeTransaction({
 			transaction: bytes,
-			signature,
-			options,
+			signatures: [signature],
+			include,
 		});
-
-		return results;
 	}
 
 	async applyEffects(effects: typeof bcs.TransactionEffects.$inferType) {
@@ -104,7 +112,7 @@ export class CachingTransactionExecutor {
 
 	async waitForLastTransaction() {
 		if (this.#lastDigest) {
-			await this.#client.waitForTransaction({ digest: this.#lastDigest });
+			await this.#client.core.waitForTransaction({ digest: this.#lastDigest });
 			this.#lastDigest = null;
 		}
 	}