react-near-ts 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright(c) 2025–2026 Volodymyr Bilyk (volodymyr@lantstool.dev)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# react-near-ts
+
+TypeScript-first React wrapper for `near-api-ts` with built-in wallet connection
+via `@hot-labs/near-connect`.
+
+## Installation
+
+```bash
+pnpm add react-near-ts react react-dom @tanstack/react-query zod
+```
+
+## Quick Start
+
+For mainnet:
+
+```tsx
+import { MainnetNearProvider } from 'react-near-ts';
+
+export const App = () => (
+  <MainnetNearProvider>
+    <h1>Hello, Near!</h1>
+  </MainnetNearProvider>
+);
+```
+
+For testnet:
+
+```tsx
+import { TestnetNearProvider } from 'react-near-ts';
+
+export const App = () => (
+  <TestnetNearProvider>
+    <h1>Hello, Near!</h1>
+  </TestnetNearProvider>
+);
+```
+
+### Custom setup
+
+```tsx
+import {
+  NearProvider,
+  createNearStore,
+  createClient,
+  createNearConnectorService,
+} from 'react-near-ts';
+
+const clientCreator = () => createClient({
+  transport: {
+    rpcEndpoints: {
+      regular: [{ url: 'https://free.rpc.fastnear.com' }],
+      archival: [{ url: 'https://1rpc.io/near' }],
+    },
+  },
+});
+
+const nearStore = createNearStore({
+  networkId: 'mainnet',
+  clientCreator,
+  serviceCreator: createNearConnectorService({ networkId: 'mainnet' }),
+});
+
+export const App = ({ children }: { children: React.ReactNode }) => (
+  <NearProvider nearStore={nearStore}>{children}</NearProvider>
+);
+```
+
+## Hooks
+
+### `useNearConnector`
+
+Connect/disconnect wallet.
+
+```tsx
+import { useNearConnector } from 'react-near-ts';
+
+const { connect, disconnect } = useNearConnector();
+
+<button onClick={() => connect.mutate()}>Connect</button>
+<button onClick={() => disconnect.mutate()}>Disconnect</button>
+```
+
+### `useConnectedAccount`
+
+Read current connected account id.
+
+```tsx
+import { useConnectedAccount } from 'react-near-ts';
+
+const { connectedAccountId, isConnectedAccount } = useConnectedAccount();
+```
+
+### `useAccountInfo`
+
+Fetch account info via JSON RPC.
+
+```tsx
+import { useAccountInfo } from 'react-near-ts';
+
+const accountInfo = useAccountInfo({ accountId: 'example.testnet' });
+
+if (accountInfo.isSuccess) {
+  console.log(accountInfo.data.accountInfo.balance.total.near);
+}
+```
+
+### `useContractReadFunction`
+
+Call read-only contract methods.
+
+```tsx
+import {
+  useContractReadFunction,
+  fromJsonBytes,
+  type DeserializeResultFnArgs,
+} from 'react-near-ts';
+import * as z from 'zod/mini';
+
+const ResultSchema = z.array(z.string());
+
+const deserializeResult = ({ rawResult }: DeserializeResultFnArgs) =>
+  ResultSchema.parse(fromJsonBytes(rawResult));
+
+const records = useContractReadFunction({
+  contractAccountId: 'react-near-ts.lantstool.testnet',
+  functionName: 'get_records',
+  functionArgs: { author_id: 'example.testnet' },
+  withStateAt: 'LatestOptimisticBlock',
+  options: { deserializeResult },
+});
+```
+
+### `useExecuteTransaction`
+
+Send signed transaction from connected wallet.
+
+```tsx
+import {
+  transfer,
+  functionCall,
+  useExecuteTransaction,
+} from 'react-near-ts';
+
+const executeTransaction = useExecuteTransaction();
+
+// Transfer
+executeTransaction.mutate({
+  intent: {
+    action: transfer({ amount: { near: '0.1' } }),
+    receiverAccountId: 'receiver.testnet',
+  },
+});
+
+// Function call
+executeTransaction.mutate({
+  intent: {
+    action: functionCall({
+      functionName: 'add_record',
+      functionArgs: { record: 'hello' },
+      gasLimit: { teraGas: '10' },
+    }),
+    receiverAccountId: 'react-near-ts.lantstool.testnet',
+  },
+});
+```
+
+## Re-exports from `near-api-ts`
+
+`react-near-ts` also re-exports common client creators, action creators and
+utils, including:
+
+- `createMainnetClient`, `createTestnetClient`, `createClient`
+- `transfer`, `functionCall`, `createAccount`, `stake`, ...
+- `near`, `yoctoNear`, `teraGas`, `fromJsonBytes`, `toJsonBytes`, ...
+
+## Playground
+
+See a full working example (Next.js App Router):
+
+- `playgrounds/react-near-ts/next-app-router`
+
+It demonstrates:
+
+- wallet connect/disconnect
+- account info fetch
+- token transfer
+- contract read/write flows

package/dist/index.d.mts

@@ -0,0 +1,175 @@
+import { UseMutationResult, UseQueryResult } from "@tanstack/react-query";
+import { ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { NearConnector } from "@hot-labs/near-connect";
+import { AccountId, BaseDeserializeResultFn, BaseSerializeArgsFn, BlockReference, CallContractReadFunctionError, CallContractReadFunctionOutput, Client, ContractFunctionName, DeserializeResultFnArgs, GetAccountInfoError, GetAccountInfoOutput, MaybeBaseDeserializeResultFn, MaybeBaseSerializeArgsFn, MaybeJsonLikeValue, PartialTransportPolicy, TransactionIntent, addFullAccessKey, addFunctionCallKey, createAccount, createClient, createMainnetClient, createTestnetClient, deleteAccount, deleteKey, deployContract, fromJsonBytes, functionCall, gas, keyPair, near, nearGas, nearToken, randomEd25519KeyPair, randomSecp256k1KeyPair, stake, teraGas, toJsonBytes, transfer, yoctoNear } from "near-api-ts";
+import { StoreApi } from "zustand";
+
+//#region types/hooks/useAccountInfo.d.ts
+type UseAccountInfoArgs = {
+  accountId?: AccountId;
+  atMomentOf?: BlockReference;
+  policies?: {
+    transport?: PartialTransportPolicy;
+  };
+  query?: {
+    enabled?: boolean;
+  };
+};
+type UseAccountInfo = (args: UseAccountInfoArgs) => UseQueryResult<GetAccountInfoOutput, GetAccountInfoError>;
+//#endregion
+//#region src/hooks/useAccountInfo.d.ts
+declare const useAccountInfo: UseAccountInfo;
+//#endregion
+//#region src/hooks/useConnectedAccount.d.ts
+declare const useConnectedAccount: () => {
+  connectedAccountId: string | undefined;
+  isConnectedAccount: boolean;
+};
+//#endregion
+//#region types/_common.d.ts
+type KeyIf<K extends PropertyKey, V> = [V] extends [undefined] ? { [P in K]?: never } : { [P in K]: V };
+type ResultOk<V> = {
+  ok: true;
+  value: V;
+};
+type ResultErr<E> = {
+  ok: false;
+  error: E;
+};
+type Result<V, E> = ResultOk<V> | ResultErr<E>;
+//#endregion
+//#region types/hooks/useContractReadFunction.d.ts
+type BaseUseContractReadFunctionArgs = {
+  contractAccountId?: AccountId;
+  functionName?: ContractFunctionName;
+  withStateAt?: BlockReference;
+  policies?: {
+    transport?: PartialTransportPolicy;
+  };
+  query?: {
+    enabled?: boolean;
+  };
+};
+type Options<A, SR extends MaybeBaseSerializeArgsFn<A>, DR extends MaybeBaseDeserializeResultFn> = [SR, DR] extends [undefined, undefined] ? {
+  options?: {
+    serializeArgs?: never;
+    deserializeResult?: never;
+  };
+} : {
+  options: KeyIf<'serializeArgs', SR> & KeyIf<'deserializeResult', DR>;
+};
+type FunctionArgsOf<SA> = SA extends ((args: {
+  functionArgs: infer T;
+}) => Uint8Array) ? T : undefined;
+type CallOutput<DR extends MaybeBaseDeserializeResultFn> = [DR] extends [BaseDeserializeResultFn] ? CallContractReadFunctionOutput<ReturnType<DR>> : CallContractReadFunctionOutput<unknown>;
+type FunctionArgs<A> = KeyIf<'functionArgs', A>;
+type UseContractReadFunction = {
+  <A extends MaybeJsonLikeValue = undefined>(args: BaseUseContractReadFunctionArgs & FunctionArgs<A> & Options<undefined, undefined, undefined>): UseQueryResult<CallOutput<undefined>, CallContractReadFunctionError>;
+  <DR extends BaseDeserializeResultFn, A extends MaybeJsonLikeValue = undefined>(args: BaseUseContractReadFunctionArgs & FunctionArgs<A> & Options<undefined, undefined, DR>): UseQueryResult<CallOutput<DR>, CallContractReadFunctionError>;
+  <SA extends BaseSerializeArgsFn<A>, DR extends MaybeBaseDeserializeResultFn = undefined, A = FunctionArgsOf<SA>>(args: BaseUseContractReadFunctionArgs & FunctionArgs<A> & Options<A, SA, DR>): UseQueryResult<CallOutput<DR>, CallContractReadFunctionError>;
+};
+//#endregion
+//#region src/hooks/useContractReadFunction.d.ts
+declare const useContractReadFunction: UseContractReadFunction;
+//#endregion
+//#region types/services/_common.d.ts
+type ServiceId = string;
+type Service<ServiceId extends string = string, ServiceBox extends Record<string, unknown> = Record<string, unknown>> = {
+  serviceId: ServiceId;
+  serviceBox: ServiceBox;
+};
+type ExecuteTransactionOutput = {
+  rawRpcResult: unknown;
+};
+type Signer<ServiceId extends string = string> = {
+  serviceId: ServiceId;
+  safeExecuteTransaction: (args: {
+    intent: TransactionIntent;
+  }) => Promise<Result<ExecuteTransactionOutput, unknown>>;
+};
+type ServiceCreator<ServiceId extends string = string, ServiceBox extends Record<string, unknown> = Record<string, unknown>> = {
+  serviceId: ServiceId;
+  createService(): Service<ServiceId, ServiceBox>;
+  createSigner(args: {
+    signerAccountId: AccountId;
+    serviceBox: ServiceBox;
+    client: Client;
+  }): Signer<ServiceId>;
+};
+//#endregion
+//#region types/hooks/useExecuteTransaction.d.ts
+type ExecuteTransactionArgs = {
+  intent: TransactionIntent;
+};
+type UseExecuteTransaction = () => UseMutationResult<ExecuteTransactionOutput, Error, ExecuteTransactionArgs, unknown>;
+//#endregion
+//#region src/hooks/useExecuteTransaction.d.ts
+declare const useExecuteTransaction: UseExecuteTransaction;
+//#endregion
+//#region types/hooks/useNearConnect.d.ts
+type UseNearConnect = () => {
+  connect: UseMutationResult<void, Error, void, unknown>;
+  disconnect: UseMutationResult<void, Error, void, unknown>;
+};
+//#endregion
+//#region src/hooks/useNearConnector.d.ts
+declare const useNearConnector: UseNearConnect;
+//#endregion
+//#region src/providers/MainnetNearProvider.d.ts
+declare const MainnetNearProvider: (props: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region types/store.d.ts
+type StoreContext = {
+  serviceCreators: ServiceCreator[];
+  client: Client;
+  services: Record<ServiceId, Service>;
+  signers: Signer[];
+};
+type NearState = {
+  networkId: string;
+  connectedAccountId?: AccountId;
+  getContext: () => StoreContext;
+  setSigners: (connectedAccountId: AccountId) => void;
+  clearSigners: () => void;
+  setConnectedAccountId: (connectedAccountId?: AccountId) => void;
+};
+type CreateNearStoreArgs = {
+  networkId: string;
+  clientCreator: () => Client;
+  serviceCreators: ServiceCreator[];
+  storeName?: string;
+};
+type NearStore = StoreApi<NearState>;
+type CreateNearStore = (args: CreateNearStoreArgs) => NearStore;
+//#endregion
+//#region src/providers/NearProvider.d.ts
+type NearProviderProps = {
+  nearStore: NearStore;
+  children: ReactNode;
+};
+declare const NearProvider: (props: NearProviderProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/providers/TestnetNearProdiver.d.ts
+declare const TestnetNearProvider: (props: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/store/nearStore.d.ts
+declare const createNearStore: CreateNearStore;
+//#endregion
+//#region types/services/nearConnect.d.ts
+type NearConnectNetworkId = 'mainnet' | 'testnet';
+type CreateNearConnectorService = (args: {
+  networkId: NearConnectNetworkId;
+}) => ServiceCreator<'nearConnector', {
+  connector: NearConnector;
+}>;
+//#endregion
+//#region src/services/nearConnector/nearConnector.d.ts
+declare const createNearConnectorService: CreateNearConnectorService;
+//#endregion
+export { type DeserializeResultFnArgs, MainnetNearProvider, NearProvider, TestnetNearProvider, addFullAccessKey, addFunctionCallKey, createAccount, createClient, createMainnetClient, createNearConnectorService, createNearStore, createTestnetClient, deleteAccount, deleteKey, deployContract, fromJsonBytes, functionCall, gas, keyPair, near, nearGas, nearToken, randomEd25519KeyPair, randomSecp256k1KeyPair, stake, teraGas, toJsonBytes, transfer, useAccountInfo, useConnectedAccount, useContractReadFunction, useExecuteTransaction, useNearConnector, yoctoNear };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,283 @@
+'use client';
+
+import { QueryClient, QueryClientProvider, skipToken, useMutation, useQuery } from "@tanstack/react-query";
+import { createContext, useContext } from "react";
+import { useStore } from "zustand/react";
+import { jsx } from "react/jsx-runtime";
+import * as z from "zod/mini";
+import { NearConnector } from "@hot-labs/near-connect";
+import { createStore } from "zustand/vanilla";
+import { persist } from "zustand/middleware";
+import { addFullAccessKey, addFunctionCallKey, createAccount, createClient, createMainnetClient, createMainnetClient as createMainnetClient$1, createTestnetClient, createTestnetClient as createTestnetClient$1, deleteAccount, deleteKey, deployContract, fromJsonBytes, functionCall, gas, keyPair, near, nearGas, nearGas as nearGas$1, nearToken, nearToken as nearToken$1, randomEd25519KeyPair, randomSecp256k1KeyPair, stake, teraGas, toJsonBytes, transfer, yoctoNear } from "near-api-ts";
+
+//#region src/store/NearStoreProvider.tsx
+const NearStoreContext = createContext(null);
+const NearStoreProvider = (props) => /* @__PURE__ */ jsx(NearStoreContext.Provider, {
+	value: props.nearStore,
+	children: props.children
+});
+const useNearStore = (selector) => {
+	const store = useContext(NearStoreContext);
+	if (!store) throw new Error("useNearStore must be used within NearStoreProvider");
+	return useStore(store, selector);
+};
+
+//#endregion
+//#region src/hooks/useAccountInfo.ts
+const useAccountInfo = (args) => {
+	const context = useNearStore((store) => store.getContext)();
+	const { accountId, query, ...rest } = args;
+	return useQuery({
+		queryKey: ["getAccountInfo", accountId],
+		queryFn: accountId ? (args) => context.client.getAccountInfo({
+			...rest,
+			accountId,
+			options: { signal: args.signal }
+		}) : skipToken,
+		enabled: query?.enabled ?? true
+	});
+};
+
+//#endregion
+//#region src/hooks/useConnectedAccount.ts
+const useConnectedAccount = () => {
+	const connectedAccountId = useNearStore((store) => store.connectedAccountId);
+	return {
+		connectedAccountId,
+		isConnectedAccount: typeof connectedAccountId === "string"
+	};
+};
+
+//#endregion
+//#region src/hooks/useContractReadFunction.ts
+const useContractReadFunction = (args) => {
+	const context = useNearStore((store) => store.getContext)();
+	const { query, contractAccountId, functionName, ...rest } = args;
+	return useQuery({
+		queryKey: [
+			"callContractReadFunction",
+			contractAccountId,
+			functionName,
+			rest.functionArgs
+		],
+		queryFn: contractAccountId && functionName ? ({ signal }) => context.client.callContractReadFunction({
+			...rest,
+			contractAccountId,
+			functionName,
+			options: {
+				...rest.options,
+				signal
+			}
+		}) : skipToken,
+		enabled: query?.enabled ?? true
+	});
+};
+
+//#endregion
+//#region src/hooks/useExecuteTransaction.ts
+const tryOnManySigners = async (args, context) => {
+	const signers = context.signers;
+	if (signers.length === 0) throw new Error("No signers available");
+	const executeTransaction = async (signerIndex) => {
+		const result = await signers[signerIndex].safeExecuteTransaction({ intent: args.intent });
+		if (result.ok) return result.value;
+		throw result.error;
+	};
+	return executeTransaction(0);
+};
+const useExecuteTransaction = () => {
+	const context = useNearStore((s) => s.getContext)();
+	return useMutation({ mutationFn: (args) => tryOnManySigners(args, context) });
+};
+
+//#endregion
+//#region src/hooks/useNearConnector.ts
+const NearConnectorServiceSchema = z.object({ nearConnector: z.object({ serviceBox: z.object({ connector: z.instanceof(NearConnector) }) }) });
+const useNearConnector = () => {
+	const getContext = useNearStore((store) => store.getContext);
+	const setSigners = useNearStore((store) => store.setSigners);
+	const clearSigners = useNearStore((store) => store.clearSigners);
+	const setConnectedAccountId = useNearStore((store) => store.setConnectedAccountId);
+	const context = getContext();
+	return {
+		connect: useMutation({ mutationFn: async () => {
+			const connectedAccountId = (await (await NearConnectorServiceSchema.parse(context.services).nearConnector.serviceBox.connector.connect()).getAccounts())[0].accountId;
+			setSigners(connectedAccountId);
+			setConnectedAccountId(connectedAccountId);
+		} }),
+		disconnect: useMutation({ mutationFn: async () => {
+			await NearConnectorServiceSchema.parse(context.services).nearConnector.serviceBox.connector.disconnect();
+			clearSigners();
+			setConnectedAccountId(void 0);
+		} })
+	};
+};
+
+//#endregion
+//#region src/store/nearStore.ts
+const createNearStore = (args) => {
+	const { storeName = "react-near-ts", networkId, clientCreator, serviceCreators } = args;
+	const services = serviceCreators.reduce((acc, creator) => {
+		acc[creator.serviceId] = creator.createService();
+		return acc;
+	}, {});
+	const context = {
+		serviceCreators,
+		client: clientCreator(),
+		services,
+		signers: []
+	};
+	const getContext = () => context;
+	const setSigners = (connectedAccountId) => {
+		context.signers = context.serviceCreators.map((creator) => creator.createSigner({
+			signerAccountId: connectedAccountId,
+			client: context.client,
+			serviceBox: context.services[creator.serviceId].serviceBox
+		}));
+	};
+	const clearSigners = () => {
+		context.signers = [];
+	};
+	return createStore()(persist((set) => ({
+		networkId,
+		connectedAccountId: void 0,
+		getContext,
+		setSigners,
+		clearSigners,
+		setConnectedAccountId: (connectedAccountId) => {
+			set(() => ({ connectedAccountId }));
+		}
+	}), {
+		name: `${storeName}:${networkId}`,
+		version: 1,
+		partialize: (s) => ({ connectedAccountId: s.connectedAccountId }),
+		onRehydrateStorage: () => (state) => {
+			if (state?.connectedAccountId) state.setSigners(state.connectedAccountId);
+		}
+	}));
+};
+
+//#endregion
+//#region src/_common/utils/result.ts
+const result = {
+	ok: (value) => ({
+		ok: true,
+		value
+	}),
+	err: (error) => ({
+		ok: false,
+		error
+	})
+};
+
+//#endregion
+//#region src/services/nearConnector/executeTransaction/toNearConnectActions.ts
+const toNearConnectAction = (action) => {
+	if (action.actionType === "CreateAccount") return { createAccount: {} };
+	if (action.actionType === "Transfer") return { transfer: { deposit: nearToken$1(action.amount).yoctoNear } };
+	if (action.actionType === "AddKey") return { addKey: {
+		publicKey: action.publicKey,
+		accessKey: {
+			nonce: 0n,
+			permission: action.accessType === "FullAccess" ? { fullAccess: {} } : { functionCall: {
+				receiverId: action.contractAccountId,
+				methodNames: action.allowedFunctions,
+				allowance: action.gasBudget ? nearToken$1(action.gasBudget).yoctoNear : void 0
+			} }
+		}
+	} };
+	if (action.actionType === "FunctionCall") return { functionCall: {
+		methodName: action.functionName,
+		args: action.functionArgs,
+		gas: nearGas$1(action.gasLimit).gas,
+		deposit: action.attachedDeposit ? nearToken$1(action.attachedDeposit).yoctoNear : 0n
+	} };
+	if (action.actionType === "DeployContract") return { deployContract: { code: action.wasmBytes } };
+	if (action.actionType === "Stake") return { stake: {
+		stake: nearToken$1(action.amount).yoctoNear,
+		publicKey: action.validatorPublicKey
+	} };
+	if (action.actionType === "DeleteKey") return { deleteKey: { publicKey: action.publicKey } };
+	if (action.actionType === "DeleteAccount") return { deleteAccount: { beneficiaryId: action.beneficiaryAccountId } };
+	throw new Error(`Unsupported action type: ${action}`);
+};
+const toNearConnectActions = (intent) => {
+	if (intent.action) return [toNearConnectAction(intent.action)];
+	if (intent.actions) return intent.actions.map((action) => toNearConnectAction(action));
+	return [];
+};
+
+//#endregion
+//#region src/services/nearConnector/executeTransaction/executeTransaction.ts
+const createSafeExecuteTransaction = (connector) => async (args) => {
+	try {
+		const finalExecutionOutcome = await (await connector.wallet()).signAndSendTransaction({
+			actions: toNearConnectActions(args.intent),
+			receiverId: args.intent.receiverAccountId
+		});
+		return result.ok({ rawRpcResult: finalExecutionOutcome });
+	} catch (e) {
+		return result.err(e);
+	}
+};
+
+//#endregion
+//#region src/services/nearConnector/nearConnector.ts
+const serviceId = "nearConnector";
+const createNearConnectorService = (args) => ({
+	serviceId,
+	createService: () => {
+		return {
+			serviceId,
+			serviceBox: { connector: new NearConnector({ network: args.networkId }) }
+		};
+	},
+	createSigner: (args) => {
+		return {
+			serviceId,
+			safeExecuteTransaction: createSafeExecuteTransaction(args.serviceBox.connector)
+		};
+	}
+});
+
+//#endregion
+//#region src/providers/NearProvider.tsx
+const queryClient = new QueryClient({ defaultOptions: {
+	queries: { retry: false },
+	mutations: { retry: false }
+} });
+const NearProvider = (props) => /* @__PURE__ */ jsx(NearStoreProvider, {
+	nearStore: props.nearStore,
+	children: /* @__PURE__ */ jsx(QueryClientProvider, {
+		client: queryClient,
+		children: props.children
+	})
+});
+
+//#endregion
+//#region src/providers/MainnetNearProvider.tsx
+const createMainnetNearStore = () => createNearStore({
+	networkId: "mainnet",
+	clientCreator: createMainnetClient$1,
+	serviceCreators: [createNearConnectorService({ networkId: "mainnet" })]
+});
+const MainnetNearProvider = (props) => /* @__PURE__ */ jsx(NearProvider, {
+	nearStore: createMainnetNearStore(),
+	children: props.children
+});
+
+//#endregion
+//#region src/providers/TestnetNearProdiver.tsx
+const createTestnetNearStore = () => createNearStore({
+	networkId: "testnet",
+	clientCreator: createTestnetClient$1,
+	serviceCreators: [createNearConnectorService({ networkId: "testnet" })]
+});
+const TestnetNearProvider = (props) => /* @__PURE__ */ jsx(NearProvider, {
+	nearStore: createTestnetNearStore(),
+	children: props.children
+});
+
+//#endregion
+export { MainnetNearProvider, NearProvider, TestnetNearProvider, addFullAccessKey, addFunctionCallKey, createAccount, createClient, createMainnetClient, createNearConnectorService, createNearStore, createTestnetClient, deleteAccount, deleteKey, deployContract, fromJsonBytes, functionCall, gas, keyPair, near, nearGas, nearToken, randomEd25519KeyPair, randomSecp256k1KeyPair, stake, teraGas, toJsonBytes, transfer, useAccountInfo, useConnectedAccount, useContractReadFunction, useExecuteTransaction, useNearConnector, yoctoNear };
+//# sourceMappingURL=index.mjs.map