@haneullabs/haneul 0.1.0

package/src/jsonRpc/errors.ts

@@ -0,0 +1,45 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+const CODE_TO_ERROR_TYPE: Record<number, string> = {
+	'-32700': 'ParseError',
+	'-32701': 'OversizedRequest',
+	'-32702': 'OversizedResponse',
+	'-32600': 'InvalidRequest',
+	'-32601': 'MethodNotFound',
+	'-32602': 'InvalidParams',
+	'-32603': 'InternalError',
+	'-32604': 'ServerBusy',
+	'-32000': 'CallExecutionFailed',
+	'-32001': 'UnknownError',
+	'-32003': 'SubscriptionClosed',
+	'-32004': 'SubscriptionClosedWithError',
+	'-32005': 'BatchesNotSupported',
+	'-32006': 'TooManySubscriptions',
+	'-32050': 'TransientError',
+	'-32002': 'TransactionExecutionClientError',
+};
+
+export class HaneulHTTPTransportError extends Error {}
+
+export class JsonRpcError extends HaneulHTTPTransportError {
+	code: number;
+	type: string;
+
+	constructor(message: string, code: number) {
+		super(message);
+		this.code = code;
+		this.type = CODE_TO_ERROR_TYPE[code] ?? 'ServerError';
+	}
+}
+
+export class HaneulHTTPStatusError extends HaneulHTTPTransportError {
+	status: number;
+	statusText: string;
+
+	constructor(message: string, status: number, statusText: string) {
+		super(message);
+		this.status = status;
+		this.statusText = statusText;
+	}
+}

package/src/jsonRpc/http-transport.ts

@@ -0,0 +1,143 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PACKAGE_VERSION, TARGETED_RPC_VERSION } from '../version.js';
+import { JsonRpcError, HaneulHTTPStatusError } from './errors.js';
+import type { WebsocketClientOptions } from './rpc-websocket-client.js';
+import { WebsocketClient } from './rpc-websocket-client.js';
+
+/**
+ * An object defining headers to be passed to the RPC server
+ */
+export type HttpHeaders = { [header: string]: string };
+
+export interface JsonRpcHTTPTransportOptions {
+	fetch?: typeof fetch;
+	WebSocketConstructor?: typeof WebSocket;
+	url: string;
+	rpc?: {
+		headers?: HttpHeaders;
+		url?: string;
+	};
+	websocket?: WebsocketClientOptions & {
+		url?: string;
+	};
+}
+
+export interface JsonRpcTransportRequestOptions {
+	method: string;
+	params: unknown[];
+	signal?: AbortSignal;
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+
+export interface JsonRpcTransportSubscribeOptions<T> {
+	method: string;
+	unsubscribe: string;
+	params: unknown[];
+	onMessage: (event: T) => void;
+	signal?: AbortSignal;
+}
+
+export interface JsonRpcTransport {
+	request<T = unknown>(input: JsonRpcTransportRequestOptions): Promise<T>;
+	subscribe<T = unknown>(
+		input: JsonRpcTransportSubscribeOptions<T>,
+	): Promise<() => Promise<boolean>>;
+}
+
+export class JsonRpcHTTPTransport implements JsonRpcTransport {
+	#requestId = 0;
+	#options: JsonRpcHTTPTransportOptions;
+	#websocketClient?: WebsocketClient;
+
+	constructor(options: JsonRpcHTTPTransportOptions) {
+		this.#options = options;
+	}
+
+	fetch(input: RequestInfo, init?: RequestInit): Promise<Response> {
+		const fetchFn = this.#options.fetch ?? fetch;
+
+		if (!fetchFn) {
+			throw new Error(
+				'The current environment does not support fetch, you can provide a fetch implementation in the options for HaneulHTTPTransport.',
+			);
+		}
+
+		return fetchFn(input, init);
+	}
+
+	#getWebsocketClient(): WebsocketClient {
+		if (!this.#websocketClient) {
+			const WebSocketConstructor = this.#options.WebSocketConstructor ?? WebSocket;
+			if (!WebSocketConstructor) {
+				throw new Error(
+					'The current environment does not support WebSocket, you can provide a WebSocketConstructor in the options for HaneulHTTPTransport.',
+				);
+			}
+
+			this.#websocketClient = new WebsocketClient(
+				this.#options.websocket?.url ?? this.#options.url,
+				{
+					WebSocketConstructor,
+					...this.#options.websocket,
+				},
+			);
+		}
+
+		return this.#websocketClient;
+	}
+
+	async request<T>(input: JsonRpcTransportRequestOptions): Promise<T> {
+		this.#requestId += 1;
+
+		const res = await this.fetch(this.#options.rpc?.url ?? this.#options.url, {
+			method: 'POST',
+			signal: input.signal,
+			headers: {
+				'Content-Type': 'application/json',
+				'Client-Sdk-Type': 'typescript',
+				'Client-Sdk-Version': PACKAGE_VERSION,
+				'Client-Target-Api-Version': TARGETED_RPC_VERSION,
+				'Client-Request-Method': input.method,
+				...this.#options.rpc?.headers,
+			},
+			body: JSON.stringify({
+				jsonrpc: '2.0',
+				id: this.#requestId,
+				method: input.method,
+				params: input.params,
+			}),
+		});
+
+		if (!res.ok) {
+			throw new HaneulHTTPStatusError(
+				`Unexpected status code: ${res.status}`,
+				res.status,
+				res.statusText,
+			);
+		}
+
+		const data = await res.json();
+
+		if ('error' in data && data.error != null) {
+			throw new JsonRpcError(data.error.message, data.error.code);
+		}
+
+		return data.result;
+	}
+
+	async subscribe<T>(input: JsonRpcTransportSubscribeOptions<T>): Promise<() => Promise<boolean>> {
+		const unsubscribe = await this.#getWebsocketClient().subscribe(input);
+
+		if (input.signal) {
+			input.signal.throwIfAborted();
+			input.signal.addEventListener('abort', () => {
+				unsubscribe();
+			});
+		}
+
+		return async () => !!(await unsubscribe());
+	}
+}

package/src/jsonRpc/index.ts

@@ -0,0 +1,20 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export {
+	type JsonRpcTransport,
+	type JsonRpcTransportRequestOptions,
+	type JsonRpcTransportSubscribeOptions,
+	type HttpHeaders,
+	type JsonRpcHTTPTransportOptions,
+	JsonRpcHTTPTransport,
+} from './http-transport.js';
+export type * from './types/index.js';
+export {
+	type HaneulJsonRpcClientOptions,
+	type PaginationArguments,
+	type OrderArguments,
+	isHaneulJsonRpcClient,
+	HaneulJsonRpcClient,
+} from './client.js';
+export { HaneulHTTPStatusError, HaneulHTTPTransportError, JsonRpcError } from './errors.js';

package/src/jsonRpc/json-rpc-resolver.ts

@@ -0,0 +1,420 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { parse } from 'valibot';
+
+import { normalizeHaneulAddress, normalizeHaneulObjectId, HANEUL_TYPE_ARG } from '../utils/index.js';
+import { ObjectRefSchema } from '../transactions/data/internal.js';
+import type { CallArg, Command, OpenMoveTypeSignature } from '../transactions/data/internal.js';
+import { Inputs } from '../transactions/Inputs.js';
+import {
+	getPureBcsSchema,
+	isTxContext,
+	normalizedTypeToMoveTypeSignature,
+} from '../transactions/serializer.js';
+import type { TransactionDataBuilder } from '../transactions/TransactionData.js';
+import { chunk } from '@haneullabs/utils';
+import type { BuildTransactionOptions } from '../transactions/index.js';
+import type { HaneulJsonRpcClient } from './client.js';
+
+// The maximum objects that can be fetched at once using multiGetObjects.
+const MAX_OBJECTS_PER_FETCH = 50;
+
+// An amount of gas (in gas units) that is added to transactions as an overhead to ensure transactions do not fail.
+const GAS_SAFE_OVERHEAD = 1000n;
+const MAX_GAS = 50_000_000_000;
+
+export function jsonRpcClientResolveTransactionPlugin(client: HaneulJsonRpcClient) {
+	return async function resolveTransactionData(
+		transactionData: TransactionDataBuilder,
+		options: BuildTransactionOptions,
+		next: () => Promise<void>,
+	) {
+		await normalizeInputs(transactionData, client);
+		await resolveObjectReferences(transactionData, client);
+
+		if (!options.onlyTransactionKind) {
+			await setGasPrice(transactionData, client);
+			await setGasBudget(transactionData, client);
+			await setGasPayment(transactionData, client);
+		}
+
+		return await next();
+	};
+}
+
+async function setGasPrice(transactionData: TransactionDataBuilder, client: HaneulJsonRpcClient) {
+	if (!transactionData.gasConfig.price) {
+		transactionData.gasConfig.price = String(await client.getReferenceGasPrice());
+	}
+}
+
+async function setGasBudget(transactionData: TransactionDataBuilder, client: HaneulJsonRpcClient) {
+	if (transactionData.gasConfig.budget) {
+		return;
+	}
+
+	const dryRunResult = await client.dryRunTransactionBlock({
+		transactionBlock: transactionData.build({
+			overrides: {
+				gasData: {
+					budget: String(MAX_GAS),
+					payment: [],
+				},
+			},
+		}),
+	});
+
+	if (dryRunResult.effects.status.status !== 'success') {
+		throw new Error(
+			`Dry run failed, could not automatically determine a budget: ${dryRunResult.effects.status.error}`,
+			{ cause: dryRunResult },
+		);
+	}
+
+	const safeOverhead = GAS_SAFE_OVERHEAD * BigInt(transactionData.gasConfig.price || 1n);
+
+	const baseComputationCostWithOverhead =
+		BigInt(dryRunResult.effects.gasUsed.computationCost) + safeOverhead;
+
+	const gasBudget =
+		baseComputationCostWithOverhead +
+		BigInt(dryRunResult.effects.gasUsed.storageCost) -
+		BigInt(dryRunResult.effects.gasUsed.storageRebate);
+
+	transactionData.gasConfig.budget = String(
+		gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead,
+	);
+}
+
+// The current default is just picking _all_ coins we can which may not be ideal.
+async function setGasPayment(transactionData: TransactionDataBuilder, client: HaneulJsonRpcClient) {
+	if (!transactionData.gasConfig.payment) {
+		const coins = await client.getCoins({
+			owner: transactionData.gasConfig.owner || transactionData.sender!,
+			coinType: HANEUL_TYPE_ARG,
+		});
+
+		const paymentCoins = coins.data
+			// Filter out coins that are also used as input:
+			.filter((coin) => {
+				const matchingInput = transactionData.inputs.find((input) => {
+					if (input.Object?.ImmOrOwnedObject) {
+						return coin.coinObjectId === input.Object.ImmOrOwnedObject.objectId;
+					}
+
+					return false;
+				});
+
+				return !matchingInput;
+			})
+			.map((coin) => ({
+				objectId: coin.coinObjectId,
+				digest: coin.digest,
+				version: coin.version,
+			}));
+
+		if (!paymentCoins.length) {
+			throw new Error('No valid gas coins found for the transaction.');
+		}
+
+		transactionData.gasConfig.payment = paymentCoins.map((payment) =>
+			parse(ObjectRefSchema, payment),
+		);
+	}
+}
+
+async function resolveObjectReferences(
+	transactionData: TransactionDataBuilder,
+	client: HaneulJsonRpcClient,
+) {
+	// Keep track of the object references that will need to be resolved at the end of the transaction.
+	// We keep the input by-reference to avoid needing to re-resolve it:
+	const objectsToResolve = transactionData.inputs.filter((input) => {
+		return (
+			input.UnresolvedObject &&
+			!(input.UnresolvedObject.version || input.UnresolvedObject?.initialSharedVersion)
+		);
+	}) as Extract<CallArg, { UnresolvedObject: unknown }>[];
+
+	const dedupedIds = [
+		...new Set(
+			objectsToResolve.map((input) => normalizeHaneulObjectId(input.UnresolvedObject.objectId)),
+		),
+	];
+
+	const objectChunks = dedupedIds.length ? chunk(dedupedIds, MAX_OBJECTS_PER_FETCH) : [];
+	const resolved = (
+		await Promise.all(
+			objectChunks.map((chunk) =>
+				client.multiGetObjects({
+					ids: chunk,
+					options: { showOwner: true },
+				}),
+			),
+		)
+	).flat();
+
+	const responsesById = new Map(
+		dedupedIds.map((id, index) => {
+			return [id, resolved[index]];
+		}),
+	);
+
+	const invalidObjects = Array.from(responsesById)
+		.filter(([_, obj]) => obj.error)
+		.map(([_, obj]) => JSON.stringify(obj.error));
+
+	if (invalidObjects.length) {
+		throw new Error(`The following input objects are invalid: ${invalidObjects.join(', ')}`);
+	}
+
+	const objects = resolved.map((object) => {
+		if (object.error || !object.data) {
+			throw new Error(`Failed to fetch object: ${object.error}`);
+		}
+		const owner = object.data.owner;
+		const initialSharedVersion =
+			owner && typeof owner === 'object'
+				? 'Shared' in owner
+					? owner.Shared.initial_shared_version
+					: 'ConsensusAddressOwner' in owner
+						? owner.ConsensusAddressOwner.start_version
+						: null
+				: null;
+
+		return {
+			objectId: object.data.objectId,
+			digest: object.data.digest,
+			version: object.data.version,
+			initialSharedVersion,
+		};
+	});
+
+	const objectsById = new Map(
+		dedupedIds.map((id, index) => {
+			return [id, objects[index]];
+		}),
+	);
+
+	for (const [index, input] of transactionData.inputs.entries()) {
+		if (!input.UnresolvedObject) {
+			continue;
+		}
+
+		let updated: CallArg | undefined;
+		const id = normalizeHaneulAddress(input.UnresolvedObject.objectId);
+		const object = objectsById.get(id);
+
+		if (input.UnresolvedObject.initialSharedVersion ?? object?.initialSharedVersion) {
+			updated = Inputs.SharedObjectRef({
+				objectId: id,
+				initialSharedVersion:
+					input.UnresolvedObject.initialSharedVersion || object?.initialSharedVersion!,
+				mutable: input.UnresolvedObject.mutable || isUsedAsMutable(transactionData, index),
+			});
+		} else if (isUsedAsReceiving(transactionData, index)) {
+			updated = Inputs.ReceivingRef(
+				{
+					objectId: id,
+					digest: input.UnresolvedObject.digest ?? object?.digest!,
+					version: input.UnresolvedObject.version ?? object?.version!,
+				}!,
+			);
+		}
+
+		transactionData.inputs[transactionData.inputs.indexOf(input)] =
+			updated ??
+			Inputs.ObjectRef({
+				objectId: id,
+				digest: input.UnresolvedObject.digest ?? object?.digest!,
+				version: input.UnresolvedObject.version ?? object?.version!,
+			});
+	}
+}
+
+async function normalizeInputs(transactionData: TransactionDataBuilder, client: HaneulJsonRpcClient) {
+	const { inputs, commands } = transactionData;
+	const moveCallsToResolve: Extract<Command, { MoveCall: unknown }>['MoveCall'][] = [];
+	const moveFunctionsToResolve = new Set<string>();
+
+	commands.forEach((command) => {
+		// Special case move call:
+		if (command.MoveCall) {
+			// Determine if any of the arguments require encoding.
+			// - If they don't, then this is good to go.
+			// - If they do, then we need to fetch the normalized move module.
+
+			// If we already know the argument types, we don't need to resolve them again
+			if (command.MoveCall._argumentTypes) {
+				return;
+			}
+
+			const inputs = command.MoveCall.arguments.map((arg) => {
+				if (arg.$kind === 'Input') {
+					return transactionData.inputs[arg.Input];
+				}
+				return null;
+			});
+			const needsResolution = inputs.some(
+				(input) =>
+					input?.UnresolvedPure ||
+					(input?.UnresolvedObject && typeof input?.UnresolvedObject.mutable !== 'boolean'),
+			);
+
+			if (needsResolution) {
+				const functionName = `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`;
+				moveFunctionsToResolve.add(functionName);
+				moveCallsToResolve.push(command.MoveCall);
+			}
+		}
+	});
+
+	const moveFunctionParameters = new Map<string, OpenMoveTypeSignature[]>();
+	if (moveFunctionsToResolve.size > 0) {
+		await Promise.all(
+			[...moveFunctionsToResolve].map(async (functionName) => {
+				const [packageId, moduleId, functionId] = functionName.split('::');
+				const def = await client.getNormalizedMoveFunction({
+					package: packageId,
+					module: moduleId,
+					function: functionId,
+				});
+
+				moveFunctionParameters.set(
+					functionName,
+					def.parameters.map((param) => normalizedTypeToMoveTypeSignature(param)),
+				);
+			}),
+		);
+	}
+
+	if (moveCallsToResolve.length) {
+		await Promise.all(
+			moveCallsToResolve.map(async (moveCall) => {
+				const parameters = moveFunctionParameters.get(
+					`${moveCall.package}::${moveCall.module}::${moveCall.function}`,
+				);
+
+				if (!parameters) {
+					return;
+				}
+
+				// Entry functions can have a mutable reference to an instance of the TxContext
+				// struct defined in the TxContext module as the last parameter. The caller of
+				// the function does not need to pass it in as an argument.
+				const hasTxContext = parameters.length > 0 && isTxContext(parameters.at(-1)!);
+				const params = hasTxContext ? parameters.slice(0, parameters.length - 1) : parameters;
+
+				moveCall._argumentTypes = params;
+			}),
+		);
+	}
+
+	commands.forEach((command) => {
+		if (!command.MoveCall) {
+			return;
+		}
+
+		const moveCall = command.MoveCall;
+		const fnName = `${moveCall.package}::${moveCall.module}::${moveCall.function}`;
+		const params = moveCall._argumentTypes;
+
+		if (!params) {
+			return;
+		}
+
+		if (params.length !== command.MoveCall.arguments.length) {
+			throw new Error(`Incorrect number of arguments for ${fnName}`);
+		}
+
+		params.forEach((param, i) => {
+			const arg = moveCall.arguments[i];
+			if (arg.$kind !== 'Input') return;
+			const input = inputs[arg.Input];
+
+			// Skip if the input is already resolved
+			if (!input.UnresolvedPure && !input.UnresolvedObject) {
+				return;
+			}
+
+			const inputValue = input.UnresolvedPure?.value ?? input.UnresolvedObject?.objectId!;
+
+			const schema = getPureBcsSchema(param.body);
+			if (schema) {
+				arg.type = 'pure';
+				inputs[inputs.indexOf(input)] = Inputs.Pure(schema.serialize(inputValue));
+				return;
+			}
+
+			if (typeof inputValue !== 'string') {
+				throw new Error(
+					`Expect the argument to be an object id string, got ${JSON.stringify(
+						inputValue,
+						null,
+						2,
+					)}`,
+				);
+			}
+
+			arg.type = 'object';
+			const unresolvedObject: typeof input = input.UnresolvedPure
+				? {
+						$kind: 'UnresolvedObject',
+						UnresolvedObject: {
+							objectId: inputValue,
+						},
+					}
+				: input;
+
+			inputs[arg.Input] = unresolvedObject;
+		});
+	});
+}
+
+function isUsedAsMutable(transactionData: TransactionDataBuilder, index: number) {
+	let usedAsMutable = false;
+
+	transactionData.getInputUses(index, (arg, tx) => {
+		if (tx.MoveCall && tx.MoveCall._argumentTypes) {
+			const argIndex = tx.MoveCall.arguments.indexOf(arg);
+			usedAsMutable = tx.MoveCall._argumentTypes[argIndex].ref !== '&' || usedAsMutable;
+		}
+
+		if (
+			tx.$kind === 'MakeMoveVec' ||
+			tx.$kind === 'MergeCoins' ||
+			tx.$kind === 'SplitCoins' ||
+			tx.$kind === 'TransferObjects'
+		) {
+			usedAsMutable = true;
+		}
+	});
+
+	return usedAsMutable;
+}
+
+function isUsedAsReceiving(transactionData: TransactionDataBuilder, index: number) {
+	let usedAsReceiving = false;
+
+	transactionData.getInputUses(index, (arg, tx) => {
+		if (tx.MoveCall && tx.MoveCall._argumentTypes) {
+			const argIndex = tx.MoveCall.arguments.indexOf(arg);
+			usedAsReceiving = isReceivingType(tx.MoveCall._argumentTypes[argIndex]) || usedAsReceiving;
+		}
+	});
+
+	return usedAsReceiving;
+}
+
+function isReceivingType(type: OpenMoveTypeSignature): boolean {
+	if (typeof type.body !== 'object' || !('datatype' in type.body)) {
+		return false;
+	}
+
+	return (
+		type.body.datatype.package === '0x2' &&
+		type.body.datatype.module === 'transfer' &&
+		type.body.datatype.type === 'Receiving'
+	);
+}