@haneullabs/dapp-kit 0.1.0 → 1.0.3

package/src/constants/walletDefaults.ts

@@ -6,16 +6,16 @@ import { SLUSH_WALLET_NAME } from '@haneullabs/slush-wallet';
 
 import { createInMemoryStore } from '../utils/stateStorage.js';
 
-export const SUI_WALLET_NAME = 'Sui Wallet';
+export const SUI_WALLET_NAME = 'Haneul Wallet';
 
 export const DEFAULT_STORAGE =
 	typeof window !== 'undefined' && window.localStorage ? localStorage : createInMemoryStore();
 
-export const DEFAULT_STORAGE_KEY = 'sui-dapp-kit:wallet-connection-info';
+export const DEFAULT_STORAGE_KEY = 'haneul-dapp-kit:wallet-connection-info';
 
 const SIGN_FEATURES = [
-	'sui:signTransaction',
-	'sui:signTransactionBlock',
+	'haneul:signTransaction',
+	'haneul:signTransactionBlock',
 ] satisfies (keyof HaneulWalletFeatures)[];
 
 export const DEFAULT_WALLET_FILTER = (wallet: WalletWithRequiredFeatures) =>

package/src/constants/walletMutationKeys.ts

@@ -12,7 +12,6 @@ export const walletMutationKeys = {
 	signTransaction: formMutationKeyFn('sign-transaction'),
 	signAndExecuteTransaction: formMutationKeyFn('sign-and-execute-transaction'),
 	switchAccount: formMutationKeyFn('switch-account'),
-	reportTransactionEffects: formMutationKeyFn('report-transaction-effects'),
 };
 
 function formMutationKeyFn(baseEntity: string) {

package/src/hooks/networkConfig.ts

@@ -1,11 +1,11 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HaneulClientOptions } from '@haneullabs/haneul/client';
+import type { HaneulJsonRpcClientOptions } from '@haneullabs/haneul/jsonRpc';
 
-import { useHaneulClientContext } from './useHaneulClient.js';
+import { useSuiClientContext } from './useHaneulClient.js';
 
-export type NetworkConfig<T extends object = object> = HaneulClientOptions & {
+export type NetworkConfig<T extends object = object> = HaneulJsonRpcClientOptions & {
 	variables?: T;
 };
 
@@ -15,7 +15,7 @@ export function createNetworkConfig<
 	Variables extends object = NonNullable<Config['variables']>,
 >(networkConfig: T) {
 	function useNetworkConfig(): Config {
-		const { config } = useHaneulClientContext();
+		const { config } = useSuiClientContext();
 
 		if (!config) {
 			throw new Error('No network config found');

package/src/hooks/useHaneulClient.ts

@@ -1,23 +1,23 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HaneulClient } from '@haneullabs/haneul/client';
+import type { HaneulJsonRpcClient } from '@haneullabs/haneul/jsonRpc';
 import { useContext } from 'react';
 
 import { HaneulClientContext } from '../components/HaneulClientProvider.js';
 
-export function useHaneulClientContext() {
-	const haneulClient = useContext(HaneulClientContext);
+export function useSuiClientContext() {
+	const suiClient = useContext(HaneulClientContext);
 
-	if (!haneulClient) {
+	if (!suiClient) {
 		throw new Error(
 			'Could not find HaneulClientContext. Ensure that you have set up the HaneulClientProvider',
 		);
 	}
 
-	return haneulClient;
+	return suiClient;
 }
 
-export function useHaneulClient(): HaneulClient {
-	return useHaneulClientContext().client;
+export function useSuiClient(): HaneulJsonRpcClient {
+	return useSuiClientContext().client;
 }

package/src/hooks/useHaneulClientInfiniteQuery.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HaneulClient } from '@haneullabs/haneul/client';
+import type { HaneulJsonRpcClient } from '@haneullabs/haneul/jsonRpc';
 import type {
 	InfiniteData,
 	UseInfiniteQueryOptions,
@@ -10,7 +10,7 @@ import type {
 import { useInfiniteQuery } from '@tanstack/react-query';
 
 import type { PartialBy } from '../types/utilityTypes.js';
-import { useHaneulClientContext } from './useHaneulClient.js';
+import { useSuiClientContext } from './useHaneulClient.js';
 
 interface PaginatedResult {
 	data?: unknown;
@@ -18,12 +18,16 @@ interface PaginatedResult {
 	hasNextPage: boolean;
 }
 
-export type SuiRpcPaginatedMethodName = {
-	[K in keyof HaneulClient]: HaneulClient[K] extends (input: any) => Promise<PaginatedResult> ? K : never;
-}[keyof HaneulClient];
+export type HaneulRpcPaginatedMethodName = {
+	[K in keyof HaneulJsonRpcClient]: HaneulJsonRpcClient[K] extends (
+		input: any,
+	) => Promise<PaginatedResult>
+		? K
+		: never;
+}[keyof HaneulJsonRpcClient];
 
-export type SuiRpcPaginatedMethods = {
-	[K in SuiRpcPaginatedMethodName]: HaneulClient[K] extends (
+export type HaneulRpcPaginatedMethods = {
+	[K in HaneulRpcPaginatedMethodName]: HaneulJsonRpcClient[K] extends (
 		input: infer Params,
 	) => Promise<
 		infer Result extends { hasNextPage?: boolean | null; nextCursor?: infer Cursor | null }
@@ -37,30 +41,30 @@ export type SuiRpcPaginatedMethods = {
 		: never;
 };
 
-export type UseHaneulClientInfiniteQueryOptions<
-	T extends keyof SuiRpcPaginatedMethods,
+export type UseSuiClientInfiniteQueryOptions<
+	T extends keyof HaneulRpcPaginatedMethods,
 	TData,
 > = PartialBy<
 	Omit<
-		UseInfiniteQueryOptions<SuiRpcPaginatedMethods[T]['result'], Error, TData, unknown[]>,
+		UseInfiniteQueryOptions<HaneulRpcPaginatedMethods[T]['result'], Error, TData, unknown[]>,
 		'queryFn' | 'initialPageParam' | 'getNextPageParam'
 	>,
 	'queryKey'
 >;
 
-export function useHaneulClientInfiniteQuery<
-	T extends keyof SuiRpcPaginatedMethods,
-	TData = InfiniteData<SuiRpcPaginatedMethods[T]['result']>,
+export function useSuiClientInfiniteQuery<
+	T extends keyof HaneulRpcPaginatedMethods,
+	TData = InfiniteData<HaneulRpcPaginatedMethods[T]['result']>,
 >(
 	method: T,
-	params: SuiRpcPaginatedMethods[T]['params'],
+	params: HaneulRpcPaginatedMethods[T]['params'],
 	{
 		queryKey = [],
 		enabled = !!params,
 		...options
-	}: UseHaneulClientInfiniteQueryOptions<T, TData> = {},
+	}: UseSuiClientInfiniteQueryOptions<T, TData> = {},
 ): UseInfiniteQueryResult<TData, Error> {
-	const suiContext = useHaneulClientContext();
+	const suiContext = useSuiClientContext();
 
 	return useInfiniteQuery({
 		...options,

package/src/hooks/useHaneulClientMutation.ts

@@ -4,19 +4,19 @@
 import type { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
 import { useMutation } from '@tanstack/react-query';
 
-import { useHaneulClientContext } from './useHaneulClient.js';
-import type { SuiRpcMethods } from './useHaneulClientQuery.js';
+import { useSuiClientContext } from './useHaneulClient.js';
+import type { HaneulRpcMethods } from './useHaneulClientQuery.js';
 
-export type UseHaneulClientMutationOptions<T extends keyof SuiRpcMethods> = Omit<
-	UseMutationOptions<SuiRpcMethods[T]['result'], Error, SuiRpcMethods[T]['params'], unknown[]>,
+export type UseSuiClientMutationOptions<T extends keyof HaneulRpcMethods> = Omit<
+	UseMutationOptions<HaneulRpcMethods[T]['result'], Error, HaneulRpcMethods[T]['params'], unknown[]>,
 	'mutationFn'
 >;
 
-export function useHaneulClientMutation<T extends keyof SuiRpcMethods>(
+export function useSuiClientMutation<T extends keyof HaneulRpcMethods>(
 	method: T,
-	options: UseHaneulClientMutationOptions<T> = {},
-): UseMutationResult<SuiRpcMethods[T]['result'], Error, SuiRpcMethods[T]['params'], unknown[]> {
-	const suiContext = useHaneulClientContext();
+	options: UseSuiClientMutationOptions<T> = {},
+): UseMutationResult<HaneulRpcMethods[T]['result'], Error, HaneulRpcMethods[T]['params'], unknown[]> {
+	const suiContext = useSuiClientContext();
 
 	return useMutation({
 		...options,

package/src/hooks/useHaneulClientQueries.ts

@@ -4,52 +4,52 @@
 import type { UseQueryResult } from '@tanstack/react-query';
 import { useQueries } from '@tanstack/react-query';
 
-import { useHaneulClientContext } from './useHaneulClient.js';
-import type { SuiRpcMethods, UseHaneulClientQueryOptions } from './useHaneulClientQuery.js';
+import { useSuiClientContext } from './useHaneulClient.js';
+import type { HaneulRpcMethods, UseSuiClientQueryOptions } from './useHaneulClientQuery.js';
 
-type HaneulClientQueryOptions = SuiRpcMethods[keyof SuiRpcMethods] extends infer Method
+type HaneulClientQueryOptions = HaneulRpcMethods[keyof HaneulRpcMethods] extends infer Method
 	? Method extends {
-			name: infer M extends keyof SuiRpcMethods;
+			name: infer M extends keyof HaneulRpcMethods;
 			params?: infer P;
 		}
 		? undefined extends P
 			? {
 					method: M;
 					params?: P;
-					options?: UseHaneulClientQueryOptions<M, unknown>;
+					options?: UseSuiClientQueryOptions<M, unknown>;
 				}
 			: {
 					method: M;
 					params: P;
-					options?: UseHaneulClientQueryOptions<M, unknown>;
+					options?: UseSuiClientQueryOptions<M, unknown>;
 				}
 		: never
 	: never;
 
-export type UseHaneulClientQueriesResults<Args extends readonly HaneulClientQueryOptions[]> = {
+export type UseSuiClientQueriesResults<Args extends readonly HaneulClientQueryOptions[]> = {
 	-readonly [K in keyof Args]: Args[K] extends {
-		method: infer M extends keyof SuiRpcMethods;
+		method: infer M extends keyof HaneulRpcMethods;
 		readonly options?:
 			| {
 					select?: (...args: any[]) => infer R;
 			  }
 			| object;
 	}
-		? UseQueryResult<unknown extends R ? SuiRpcMethods[M]['result'] : R>
+		? UseQueryResult<unknown extends R ? HaneulRpcMethods[M]['result'] : R>
 		: never;
 };
 
-export function useHaneulClientQueries<
+export function useSuiClientQueries<
 	const Queries extends readonly HaneulClientQueryOptions[],
-	Results = UseHaneulClientQueriesResults<Queries>,
+	Results = UseSuiClientQueriesResults<Queries>,
 >({
 	queries,
 	combine,
 }: {
 	queries: Queries;
-	combine?: (results: UseHaneulClientQueriesResults<Queries>) => Results;
+	combine?: (results: UseSuiClientQueriesResults<Queries>) => Results;
 }): Results {
-	const suiContext = useHaneulClientContext();
+	const suiContext = useSuiClientContext();
 
 	return useQueries({
 		combine: combine as never,

package/src/hooks/useHaneulClientQuery.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HaneulClient } from '@haneullabs/haneul/client';
+import type { HaneulJsonRpcClient } from '@haneullabs/haneul/jsonRpc';
 import type {
 	UndefinedInitialDataOptions,
 	UseQueryOptions,
@@ -11,22 +11,24 @@ import { queryOptions, useQuery, useSuspenseQuery } from '@tanstack/react-query'
 import { useMemo } from 'react';
 
 import type { PartialBy } from '../types/utilityTypes.js';
-import { useHaneulClientContext } from './useHaneulClient.js';
+import { useSuiClientContext } from './useHaneulClient.js';
 
-export type SuiRpcMethodName = {
-	[K in keyof HaneulClient]: HaneulClient[K] extends ((input: any) => Promise<any>) | (() => Promise<any>)
+export type HaneulRpcMethodName = {
+	[K in keyof HaneulJsonRpcClient]: HaneulJsonRpcClient[K] extends
+		| ((input: any) => Promise<any>)
+		| (() => Promise<any>)
 		? K
 		: never;
-}[keyof HaneulClient];
+}[keyof HaneulJsonRpcClient];
 
-export type SuiRpcMethods = {
-	[K in SuiRpcMethodName]: HaneulClient[K] extends (input: infer P) => Promise<infer R>
+export type HaneulRpcMethods = {
+	[K in HaneulRpcMethodName]: HaneulJsonRpcClient[K] extends (input: infer P) => Promise<infer R>
 		? {
 				name: K;
 				result: R;
 				params: P;
 			}
-		: HaneulClient[K] extends () => Promise<infer R>
+		: HaneulJsonRpcClient[K] extends () => Promise<infer R>
 			? {
 					name: K;
 					result: R;
@@ -35,31 +37,31 @@ export type SuiRpcMethods = {
 			: never;
 };
 
-export type UseHaneulClientQueryOptions<T extends keyof SuiRpcMethods, TData> = PartialBy<
-	Omit<UseQueryOptions<SuiRpcMethods[T]['result'], Error, TData, unknown[]>, 'queryFn'>,
+export type UseSuiClientQueryOptions<T extends keyof HaneulRpcMethods, TData> = PartialBy<
+	Omit<UseQueryOptions<HaneulRpcMethods[T]['result'], Error, TData, unknown[]>, 'queryFn'>,
 	'queryKey'
 >;
 
-export type GetHaneulClientQueryOptions<T extends keyof SuiRpcMethods> = {
-	client: HaneulClient;
+export type GetSuiClientQueryOptions<T extends keyof HaneulRpcMethods> = {
+	client: HaneulJsonRpcClient;
 	network: string;
 	method: T;
 	options?: PartialBy<
-		Omit<UndefinedInitialDataOptions<SuiRpcMethods[T]['result']>, 'queryFn'>,
+		Omit<UndefinedInitialDataOptions<HaneulRpcMethods[T]['result']>, 'queryFn'>,
 		'queryKey'
 	>;
-} & (undefined extends SuiRpcMethods[T]['params']
-	? { params?: SuiRpcMethods[T]['params'] }
-	: { params: SuiRpcMethods[T]['params'] });
+} & (undefined extends HaneulRpcMethods[T]['params']
+	? { params?: HaneulRpcMethods[T]['params'] }
+	: { params: HaneulRpcMethods[T]['params'] });
 
-export function getHaneulClientQuery<T extends keyof SuiRpcMethods>({
+export function getSuiClientQuery<T extends keyof HaneulRpcMethods>({
 	client,
 	network,
 	method,
 	params,
 	options,
-}: GetHaneulClientQueryOptions<T>) {
-	return queryOptions<SuiRpcMethods[T]['result']>({
+}: GetSuiClientQueryOptions<T>) {
+	return queryOptions<HaneulRpcMethods[T]['result']>({
 		...options,
 		queryKey: [network, method, params],
 		queryFn: async () => {
@@ -68,21 +70,21 @@ export function getHaneulClientQuery<T extends keyof SuiRpcMethods>({
 	});
 }
 
-export function useHaneulClientQuery<
-	T extends keyof SuiRpcMethods,
-	TData = SuiRpcMethods[T]['result'],
+export function useSuiClientQuery<
+	T extends keyof HaneulRpcMethods,
+	TData = HaneulRpcMethods[T]['result'],
 >(
-	...args: undefined extends SuiRpcMethods[T]['params']
-		? [method: T, params?: SuiRpcMethods[T]['params'], options?: UseHaneulClientQueryOptions<T, TData>]
-		: [method: T, params: SuiRpcMethods[T]['params'], options?: UseHaneulClientQueryOptions<T, TData>]
+	...args: undefined extends HaneulRpcMethods[T]['params']
+		? [method: T, params?: HaneulRpcMethods[T]['params'], options?: UseSuiClientQueryOptions<T, TData>]
+		: [method: T, params: HaneulRpcMethods[T]['params'], options?: UseSuiClientQueryOptions<T, TData>]
 ): UseQueryResult<TData, Error> {
 	const [method, params, { queryKey = [], ...options } = {}] = args as [
 		method: T,
-		params?: SuiRpcMethods[T]['params'],
-		options?: UseHaneulClientQueryOptions<T, TData>,
+		params?: HaneulRpcMethods[T]['params'],
+		options?: UseSuiClientQueryOptions<T, TData>,
 	];
 
-	const suiContext = useHaneulClientContext();
+	const suiContext = useSuiClientContext();
 
 	return useQuery({
 		...options,
@@ -93,24 +95,24 @@ export function useHaneulClientQuery<
 	});
 }
 
-export function useHaneulClientSuspenseQuery<
-	T extends keyof SuiRpcMethods,
-	TData = SuiRpcMethods[T]['result'],
+export function useSuiClientSuspenseQuery<
+	T extends keyof HaneulRpcMethods,
+	TData = HaneulRpcMethods[T]['result'],
 >(
-	...args: undefined extends SuiRpcMethods[T]['params']
-		? [method: T, params?: SuiRpcMethods[T]['params'], options?: UndefinedInitialDataOptions<TData>]
-		: [method: T, params: SuiRpcMethods[T]['params'], options?: UndefinedInitialDataOptions<TData>]
+	...args: undefined extends HaneulRpcMethods[T]['params']
+		? [method: T, params?: HaneulRpcMethods[T]['params'], options?: UndefinedInitialDataOptions<TData>]
+		: [method: T, params: HaneulRpcMethods[T]['params'], options?: UndefinedInitialDataOptions<TData>]
 ) {
 	const [method, params, options = {}] = args as [
 		method: T,
-		params?: SuiRpcMethods[T]['params'],
+		params?: HaneulRpcMethods[T]['params'],
 		options?: UndefinedInitialDataOptions<TData>,
 	];
 
-	const suiContext = useHaneulClientContext();
+	const suiContext = useSuiClientContext();
 
 	const query = useMemo(() => {
-		return getHaneulClientQuery<T>({
+		return getSuiClientQuery<T>({
 			client: suiContext.client,
 			network: suiContext.network,
 			method,

package/src/hooks/useResolveHaneulNSNames.ts

@@ -1,10 +1,10 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { ResolvedNameServiceNames } from '@haneullabs/haneul/client';
+import type { ResolvedNameServiceNames } from '@haneullabs/haneul/jsonRpc';
 import type { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
 
-import { useHaneulClientQuery } from './useHaneulClientQuery.js';
+import { useSuiClientQuery } from './useHaneulClientQuery.js';
 
 export function useResolveHaneulNSName(
 	address?: string | null,
@@ -13,7 +13,7 @@ export function useResolveHaneulNSName(
 		'queryFn' | 'queryKey' | 'select'
 	>,
 ): UseQueryResult<string | null, Error> {
-	return useHaneulClientQuery(
+	return useSuiClientQuery(
 		'resolveNameServiceNames',
 		{
 			address: address!,

package/src/hooks/wallet/useAutoConnectWallet.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { useQuery } from '@tanstack/react-query';
-import { useLayoutEffect, useState } from 'react';
+import { useEffect, useLayoutEffect, useState } from 'react';
 
 import { getWalletUniqueIdentifier } from '../../utils/walletUtils.js';
 import { useConnectWallet } from './useConnectWallet.js';
@@ -19,7 +19,8 @@ export function useAutoConnectWallet(): 'disabled' | 'idle' | 'attempted' {
 	const { isConnected } = useCurrentWallet();
 
 	const [clientOnly, setClientOnly] = useState(false);
-	useLayoutEffect(() => {
+	const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+	useIsomorphicLayoutEffect(() => {
 		setClientOnly(true);
 	}, []);
 

package/src/hooks/wallet/useConnectWallet.ts

@@ -51,18 +51,18 @@ export function useConnectWallet({
 
 				const connectResult = await wallet.features['standard:connect'].connect(connectArgs);
 				let supportedIntents = connectResult.supportedIntents;
-				if (!supportedIntents && wallet.features['sui:getCapabilities']) {
+				if (!supportedIntents && wallet.features['haneul:getCapabilities']) {
 					supportedIntents =
-						(await wallet.features['sui:getCapabilities'].getCapabilities()).supportedIntents ?? [];
+						(await wallet.features['haneul:getCapabilities'].getCapabilities()).supportedIntents ?? [];
 				}
-				const connectedHaneulAccounts = connectResult.accounts.filter((account) =>
-					account.chains.some((chain) => chain.split(':')[0] === 'sui'),
+				const connectedSuiAccounts = connectResult.accounts.filter((account) =>
+					account.chains.some((chain) => chain.split(':')[0] === 'haneul'),
 				);
-				const selectedAccount = getSelectedAccount(connectedHaneulAccounts, accountAddress);
+				const selectedAccount = getSelectedAccount(connectedSuiAccounts, accountAddress);
 
-				setWalletConnected(wallet, connectedHaneulAccounts, selectedAccount, supportedIntents);
+				setWalletConnected(wallet, connectedSuiAccounts, selectedAccount, supportedIntents);
 
-				return { accounts: connectedHaneulAccounts };
+				return { accounts: connectedSuiAccounts };
 			} catch (error) {
 				setConnectionStatus('disconnected');
 				throw error;

package/src/hooks/wallet/useSignAndExecuteTransaction.ts

@@ -18,10 +18,9 @@ import {
 	WalletNotConnectedError,
 } from '../../errors/walletErrors.js';
 import type { PartialBy } from '../../types/utilityTypes.js';
-import { useHaneulClientContext } from '../useHaneulClient.js';
+import { useSuiClientContext } from '../useHaneulClient.js';
 import { useCurrentAccount } from './useCurrentAccount.js';
 import { useCurrentWallet } from './useCurrentWallet.js';
-import { useReportTransactionEffects } from './useReportTransactionEffects.js';
 
 type UseSignAndExecuteTransactionArgs = PartialBy<
 	Omit<HaneulSignAndExecuteTransactionInput, 'transaction'>,
@@ -77,8 +76,7 @@ export function useSignAndExecuteTransaction<
 > {
 	const { currentWallet, supportedIntents } = useCurrentWallet();
 	const currentAccount = useCurrentAccount();
-	const { client, network } = useHaneulClientContext();
-	const { mutate: reportTransactionEffects } = useReportTransactionEffects();
+	const { client, network } = useSuiClientContext();
 
 	const executeTransaction: ({
 		bytes,
@@ -121,8 +119,8 @@ export function useSignAndExecuteTransaction<
 			}
 
 			if (
-				!currentWallet.features['sui:signTransaction'] &&
-				!currentWallet.features['sui:signTransactionBlock']
+				!currentWallet.features['haneul:signTransaction'] &&
+				!currentWallet.features['haneul:signTransactionBlock']
 			) {
 				throw new WalletFeatureNotSupportedError(
 					"This wallet doesn't support the `signTransaction` feature.",
@@ -133,7 +131,7 @@ export function useSignAndExecuteTransaction<
 				transaction.setSenderIfNotSet(signerAccount.address);
 			}
 
-			const chain = signTransactionArgs.chain ?? `sui:${network}`;
+			const chain = signTransactionArgs.chain ?? `haneul:${network}`;
 			const { signature, bytes } = await signTransaction(currentWallet, {
 				...signTransactionArgs,
 				transaction: {
@@ -152,18 +150,6 @@ export function useSignAndExecuteTransaction<
 
 			const result = await executeTransaction({ bytes, signature });
 
-			let effects: string;
-
-			if ('effects' in result && result.effects?.bcs) {
-				effects = result.effects.bcs;
-			} else if ('rawEffects' in result) {
-				effects = toBase64(new Uint8Array(result.rawEffects!));
-			} else {
-				throw new Error('Could not parse effects from transaction result.');
-			}
-
-			reportTransactionEffects({ effects, account: signerAccount, chain });
-
 			return result as Result;
 		},
 		...mutationOptions,

package/src/hooks/wallet/useSignPersonalMessage.ts

@@ -15,7 +15,7 @@ import {
 } from '../..//errors/walletErrors.js';
 import { walletMutationKeys } from '../../constants/walletMutationKeys.js';
 import type { PartialBy } from '../../types/utilityTypes.js';
-import { useHaneulClientContext } from '../useHaneulClient.js';
+import { useSuiClientContext } from '../useHaneulClient.js';
 import { useCurrentAccount } from './useCurrentAccount.js';
 import { useCurrentWallet } from './useCurrentWallet.js';
 
@@ -52,7 +52,7 @@ export function useSignPersonalMessage({
 > {
 	const { currentWallet } = useCurrentWallet();
 	const currentAccount = useCurrentAccount();
-	const { network } = useHaneulClientContext();
+	const { network } = useSuiClientContext();
 
 	return useMutation({
 		mutationKey: walletMutationKeys.signPersonalMessage(mutationKey),
@@ -68,17 +68,17 @@ export function useSignPersonalMessage({
 				);
 			}
 
-			const signPersonalMessageFeature = currentWallet.features['sui:signPersonalMessage'];
+			const signPersonalMessageFeature = currentWallet.features['haneul:signPersonalMessage'];
 			if (signPersonalMessageFeature) {
 				return await signPersonalMessageFeature.signPersonalMessage({
 					...signPersonalMessageArgs,
 					account: signerAccount,
-					chain: signPersonalMessageArgs.chain ?? `sui:${network}`,
+					chain: signPersonalMessageArgs.chain ?? `haneul:${network}`,
 				});
 			}
 
-			// TODO: Remove this once we officially discontinue sui:signMessage in the wallet standard
-			const signMessageFeature = currentWallet.features['sui:signMessage'];
+			// TODO: Remove this once we officially discontinue haneul:signMessage in the wallet standard
+			const signMessageFeature = currentWallet.features['haneul:signMessage'];
 			if (signMessageFeature) {
 				console.warn(
 					"This wallet doesn't support the `signPersonalMessage` feature... falling back to `signMessage`.",

package/src/hooks/wallet/useSignTransaction.ts

@@ -14,10 +14,9 @@ import {
 	WalletNotConnectedError,
 } from '../../errors/walletErrors.js';
 import type { PartialBy } from '../../types/utilityTypes.js';
-import { useHaneulClientContext } from '../useHaneulClient.js';
+import { useSuiClientContext } from '../useHaneulClient.js';
 import { useCurrentAccount } from './useCurrentAccount.js';
 import { useCurrentWallet } from './useCurrentWallet.js';
-import { useReportTransactionEffects } from './useReportTransactionEffects.js';
 
 type UseSignTransactionArgs = PartialBy<
 	Omit<HaneulSignTransactionInput, 'transaction'>,
@@ -26,9 +25,7 @@ type UseSignTransactionArgs = PartialBy<
 	transaction: Transaction | string;
 };
 
-interface UseSignTransactionResult extends SignedTransaction {
-	reportTransactionEffects: (effects: string) => void;
-}
+interface UseSignTransactionResult extends SignedTransaction {}
 
 type UseSignTransactionError =
 	| WalletFeatureNotSupportedError
@@ -59,9 +56,7 @@ export function useSignTransaction({
 > {
 	const { currentWallet } = useCurrentWallet();
 	const currentAccount = useCurrentAccount();
-	const { client, network } = useHaneulClientContext();
-
-	const { mutate: reportTransactionEffects } = useReportTransactionEffects();
+	const { client, network } = useSuiClientContext();
 
 	return useMutation({
 		mutationKey: walletMutationKeys.signTransaction(mutationKey),
@@ -78,8 +73,8 @@ export function useSignTransaction({
 			}
 
 			if (
-				!currentWallet.features['sui:signTransaction'] &&
-				!currentWallet.features['sui:signTransactionBlock']
+				!currentWallet.features['haneul:signTransaction'] &&
+				!currentWallet.features['haneul:signTransactionBlock']
 			) {
 				throw new WalletFeatureNotSupportedError(
 					"This wallet doesn't support the `signTransaction` feature.",
@@ -90,7 +85,7 @@ export function useSignTransaction({
 				transaction.setSenderIfNotSet(signerAccount.address);
 			}
 
-			const chain = signTransactionArgs.chain ?? `sui:${network}`;
+			const chain = signTransactionArgs.chain ?? `haneul:${network}`;
 			const { bytes, signature } = await signTransaction(currentWallet, {
 				...signTransactionArgs,
 				transaction: {
@@ -110,13 +105,6 @@ export function useSignTransaction({
 			return {
 				bytes,
 				signature,
-				reportTransactionEffects: (effects) => {
-					reportTransactionEffects({
-						effects,
-						account: signerAccount,
-						chain,
-					});
-				},
 			};
 		},
 		...mutationOptions,