react-near-ts 0.1.0

package/types/hooks/useAccountInfo.ts

@@ -0,0 +1,23 @@
+import type {
+  AccountId,
+  GetAccountInfoOutput,
+  GetAccountInfoError,
+  BlockReference,
+  PartialTransportPolicy,
+} from 'near-api-ts';
+import type { UseQueryResult } from '@tanstack/react-query';
+
+type UseAccountInfoArgs = {
+  accountId?: AccountId;
+  atMomentOf?: BlockReference;
+  policies?: {
+    transport?: PartialTransportPolicy;
+  };
+  query?: {
+    enabled?: boolean;
+  };
+};
+
+export type UseAccountInfo = (
+  args: UseAccountInfoArgs,
+) => UseQueryResult<GetAccountInfoOutput, GetAccountInfoError>;

package/types/hooks/useContractReadFunction.ts

@@ -0,0 +1,78 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import type {
+  AccountId,
+  BaseDeserializeResultFn,
+  BaseSerializeArgsFn,
+  BlockReference,
+  CallContractReadFunctionError,
+  CallContractReadFunctionOutput,
+  MaybeBaseDeserializeResultFn,
+  MaybeBaseSerializeArgsFn,
+  MaybeJsonLikeValue,
+  PartialTransportPolicy,
+  ContractFunctionName,
+} from 'near-api-ts';
+import type { KeyIf } from '../_common.ts';
+
+export type BaseUseContractReadFunctionArgs = {
+  contractAccountId?: AccountId;
+  functionName?: ContractFunctionName;
+  withStateAt?: BlockReference;
+  policies?: {
+    transport?: PartialTransportPolicy;
+  };
+  query?: {
+    enabled?: boolean;
+  };
+};
+
+export type InnerUseContractReadFunctionArgs = BaseUseContractReadFunctionArgs & {
+  functionArgs?: any;
+  options?: {
+    serializeArgs?: BaseSerializeArgsFn<any>;
+    deserializeResult?: BaseDeserializeResultFn;
+  };
+};
+
+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>;
+    };
+
+// Return type of functionArgs or undefined
+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>;
+
+export type UseContractReadFunction = {
+  // #1
+  <A extends MaybeJsonLikeValue = undefined>(
+    args: BaseUseContractReadFunctionArgs &
+      FunctionArgs<A> &
+      Options<undefined, undefined, undefined>,
+  ): UseQueryResult<CallOutput<undefined>, CallContractReadFunctionError>;
+  // #2
+  <DR extends BaseDeserializeResultFn, A extends MaybeJsonLikeValue = undefined>(
+    args: BaseUseContractReadFunctionArgs & FunctionArgs<A> & Options<undefined, undefined, DR>,
+  ): UseQueryResult<CallOutput<DR>, CallContractReadFunctionError>;
+  // #3
+  <
+    SA extends BaseSerializeArgsFn<A>,
+    DR extends MaybeBaseDeserializeResultFn = undefined,
+    A = FunctionArgsOf<SA>,
+  >(
+    args: BaseUseContractReadFunctionArgs & FunctionArgs<A> & Options<A, SA, DR>,
+  ): UseQueryResult<CallOutput<DR>, CallContractReadFunctionError>;
+};

package/types/hooks/useExecuteTransaction.ts

@@ -0,0 +1,14 @@
+import type { UseMutationResult } from '@tanstack/react-query';
+import type { ExecuteTransactionOutput } from '../services/_common.ts';
+import type { TransactionIntent } from 'near-api-ts';
+
+export type ExecuteTransactionArgs = {
+  intent: TransactionIntent;
+};
+
+export type UseExecuteTransaction = () => UseMutationResult<
+  ExecuteTransactionOutput,
+  Error,
+  ExecuteTransactionArgs,
+  unknown
+>;

package/types/hooks/useNearConnect.ts

@@ -0,0 +1,6 @@
+import type { UseMutationResult } from '@tanstack/react-query';
+
+export type UseNearConnect = () => {
+  connect: UseMutationResult<void, Error, void, unknown>;
+  disconnect: UseMutationResult<void, Error, void, unknown>;
+};

package/types/services/_common.ts

@@ -0,0 +1,36 @@
+import type { TransactionIntent, AccountId, Client } from 'near-api-ts';
+import type { Result } from '../_common.ts';
+
+export type ServiceId = string;
+
+export type Service<
+  ServiceId extends string = string,
+  ServiceBox extends Record<string, unknown> = Record<string, unknown>,
+> = {
+  serviceId: ServiceId;
+  serviceBox: ServiceBox;
+};
+
+export type ExecuteTransactionOutput = {
+  rawRpcResult: unknown;
+};
+
+export type Signer<ServiceId extends string = string> = {
+  serviceId: ServiceId;
+  safeExecuteTransaction: (args: {
+    intent: TransactionIntent;
+  }) => Promise<Result<ExecuteTransactionOutput, unknown>>;
+};
+
+export 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>;
+};

package/types/services/nearConnect.ts

@@ -0,0 +1,99 @@
+import type { NearConnector } from '@hot-labs/near-connect';
+import type { TransactionIntent, PublicKey, AccountId } from 'near-api-ts';
+import type { Result } from '../_common.ts';
+import type { ServiceCreator } from './_common.ts';
+
+type CreateAccountAction = {
+  createAccount: {};
+};
+
+type TransferAction = {
+  transfer: {
+    deposit: bigint;
+  };
+};
+
+type AddKeyAction = {
+  addKey: {
+    publicKey: PublicKey;
+    accessKey: {
+      nonce: bigint;
+      permission:
+        | { fullAccess: {} }
+        | {
+            functionCall: {
+              receiverId: string;
+              allowance?: bigint;
+              methodNames?: string[];
+            };
+          };
+    };
+  };
+};
+
+type FunctionCallAction = {
+  functionCall: {
+    methodName: string;
+    args: Uint8Array;
+    gas: bigint;
+    deposit: bigint;
+  };
+};
+
+type DeployContractAction = {
+  deployContract: {
+    code: Uint8Array;
+  };
+};
+
+type StakeAction = {
+  stake: {
+    stake: bigint;
+    publicKey: PublicKey;
+  };
+};
+
+type DeleteKeyAction = {
+  deleteKey: {
+    publicKey: PublicKey;
+  };
+};
+
+type DeleteAccountAction = {
+  deleteAccount: {
+    beneficiaryId: AccountId;
+  };
+};
+
+export type NearConnectAction =
+  | CreateAccountAction
+  | TransferAction
+  | AddKeyAction
+  | FunctionCallAction
+  | DeployContractAction
+  | StakeAction
+  | DeleteKeyAction
+  | DeleteAccountAction;
+
+type ExecuteTransactionArgs = {
+  intent: TransactionIntent;
+};
+
+type ExecuteTransactionOutput = {
+  rawRpcResult: unknown;
+};
+
+export type CreateSafeExecuteTransaction = (
+  connector: NearConnector,
+) => (args: ExecuteTransactionArgs) => Promise<Result<ExecuteTransactionOutput, unknown>>;
+
+export type NearConnectNetworkId = 'mainnet' | 'testnet';
+
+export type NearConnectServiceCreator = ServiceCreator<
+  'nearConnector',
+  { connector: NearConnector }
+>;
+
+export type CreateNearConnectorService = (args: {
+  networkId: NearConnectNetworkId;
+}) => NearConnectServiceCreator;

package/types/store.ts

@@ -0,0 +1,30 @@
+import type { Client, AccountId } from 'near-api-ts';
+import type { Service, ServiceCreator, Signer, ServiceId } from './services/_common';
+import type { StoreApi } from 'zustand';
+import type { NearConnectServiceCreator } from './services/nearConnect.ts';
+
+export type StoreContext = {
+  serviceCreators: ServiceCreator[];
+  client: Client;
+  services: Record<ServiceId, Service>;
+  signers: Signer[];
+};
+
+export type NearState = {
+  networkId: string;
+  connectedAccountId?: AccountId;
+  getContext: () => StoreContext;
+  setSigners: (connectedAccountId: AccountId) => void;
+  clearSigners: () => void;
+  setConnectedAccountId: (connectedAccountId?: AccountId) => void;
+};
+
+export type CreateNearStoreArgs = {
+  networkId: string;
+  clientCreator: () => Client;
+  serviceCreator: NearConnectServiceCreator;
+  storeName?: string;
+};
+
+export type NearStore = StoreApi<NearState>;
+export type CreateNearStore = (args: CreateNearStoreArgs) => NearStore;