@aave/react 4.0.0-next.1 → 4.0.0-next.2

package/dist/writes-BXnwYgAQ.d.cts

@@ -0,0 +1,123 @@
+import { TransactionResult } from '@aave/client';
+import { CancelError, TimeoutError, TransactionError, UnexpectedError, SigningError } from '@aave/core';
+import { TransactionRequest, Erc20ApprovalRequired, PreContractActionRequired } from '@aave/graphql';
+import { ResultAsync } from '@aave/types';
+
+/**
+ * An async task is a function that can be executed multiple times and that can be in a pending state.
+ *
+ * @internal
+ */
+type AsyncTask<TInput, TResult extends ResultAsync<unknown, unknown>> = (input: TInput) => TResult;
+/**
+ * The initial state of a async task.
+ */
+type AsyncTaskIdle = {
+    called: boolean;
+    loading: false;
+    data: undefined;
+    error: undefined;
+};
+/**
+ * The state of a async task during the loading.
+ */
+type AsyncTaskLoading<TData> = {
+    called: true;
+    loading: true;
+    data: TData | undefined;
+    error: undefined;
+};
+/**
+ * The state of a async task after a successful call.
+ */
+type AsyncTaskSuccess<TData> = {
+    called: true;
+    loading: false;
+    data: TData;
+    error: undefined;
+};
+/**
+ * The state of a async task after a failed call.
+ */
+type AsyncTaskError<TError> = {
+    called: true;
+    loading: false;
+    data: undefined;
+    error: TError;
+};
+/**
+ * The possible statuses of a async task.
+ */
+type AsyncTaskState<TData, TError> = AsyncTaskIdle | AsyncTaskLoading<TData> | AsyncTaskSuccess<TData> | AsyncTaskError<TError>;
+/**
+ * A async task React Hook is a lightweight wrapper for an asynchronous function.
+ * It allows tracking of the task's execution status and provides access to the
+ * last error that occurred during the task's execution, if any.
+ *
+ * ```ts
+ * const [execute, { called, loading, data, error }]: UseAsyncTask<TData, TError, TInput> = useAnyAsyncTask();
+ *
+ * if (!called) {
+ *   // data === undefined
+ *   // error === undefined
+ *   return <p>Click the button to execute the task</p>;
+ * }
+ *
+ * if (loading) {
+ *   // data === undefined on first call
+ *   // data === TData from previous successful call
+ *   // error === undefined
+ *   return <Loader />;
+ * }
+ *
+ * if (error) {
+ *   // data === undefined
+ *   // error === TError
+ *   return <p>Something went wrong: {error.message}</p>;
+ * }
+ *
+ * // called === true
+ * // data === TData
+ * // error === undefined
+ * return <p>Task completed: {data}</p>;
+ * ```
+ */
+type UseAsyncTask<TInput, TValue, TError> = [
+    AsyncTask<TInput, ResultAsync<TValue, TError>>,
+    AsyncTaskState<TValue, TError>
+];
+
+/**
+ * The errors that could occur in the early stage of sending a transaction.
+ */
+type SendTransactionError = CancelError | SigningError | UnexpectedError;
+type CancelOperation = (message: string) => ResultAsync<never, CancelError>;
+type TransactionHandlerOptions = {
+    cancel: CancelOperation;
+};
+/**
+ * The errors that could occur in the late stages of a transaction.
+ */
+type PendingTransactionError = CancelError | TimeoutError | TransactionError | UnexpectedError;
+declare class PendingTransaction {
+    /**
+     * @internal Do NOT rely on this method. It's used internally by the SDK and may be subject to breaking changes.
+     */
+    readonly wait: () => ResultAsync<TransactionResult, PendingTransactionError>;
+    constructor(
+    /**
+     * @internal Do NOT rely on this method. It's used internally by the SDK and may be subject to breaking changes.
+     */
+    wait: () => ResultAsync<TransactionResult, PendingTransactionError>);
+    /**
+     * @internal
+     */
+    static ensure<T>(value: T): PendingTransaction & T;
+}
+type UseSendTransactionResult = UseAsyncTask<TransactionRequest, PendingTransaction, SendTransactionError>;
+/**
+ * The handler for sending Aave transactions.
+ */
+type TransactionHandler = (result: TransactionRequest | Erc20ApprovalRequired | PreContractActionRequired, options: TransactionHandlerOptions) => ResultAsync<PendingTransaction, SendTransactionError>;
+
+export { type AsyncTaskError as A, type CancelOperation as C, type PendingTransactionError as P, type SendTransactionError as S, type TransactionHandler as T, type UseSendTransactionResult as U, type UseAsyncTask as a, PendingTransaction as b, type AsyncTaskIdle as c, type AsyncTaskLoading as d, type AsyncTaskState as e, type AsyncTaskSuccess as f, type TransactionHandlerOptions as g };

package/dist/writes-BXnwYgAQ.d.ts

@@ -0,0 +1,123 @@
+import { TransactionResult } from '@aave/client';
+import { CancelError, TimeoutError, TransactionError, UnexpectedError, SigningError } from '@aave/core';
+import { TransactionRequest, Erc20ApprovalRequired, PreContractActionRequired } from '@aave/graphql';
+import { ResultAsync } from '@aave/types';
+
+/**
+ * An async task is a function that can be executed multiple times and that can be in a pending state.
+ *
+ * @internal
+ */
+type AsyncTask<TInput, TResult extends ResultAsync<unknown, unknown>> = (input: TInput) => TResult;
+/**
+ * The initial state of a async task.
+ */
+type AsyncTaskIdle = {
+    called: boolean;
+    loading: false;
+    data: undefined;
+    error: undefined;
+};
+/**
+ * The state of a async task during the loading.
+ */
+type AsyncTaskLoading<TData> = {
+    called: true;
+    loading: true;
+    data: TData | undefined;
+    error: undefined;
+};
+/**
+ * The state of a async task after a successful call.
+ */
+type AsyncTaskSuccess<TData> = {
+    called: true;
+    loading: false;
+    data: TData;
+    error: undefined;
+};
+/**
+ * The state of a async task after a failed call.
+ */
+type AsyncTaskError<TError> = {
+    called: true;
+    loading: false;
+    data: undefined;
+    error: TError;
+};
+/**
+ * The possible statuses of a async task.
+ */
+type AsyncTaskState<TData, TError> = AsyncTaskIdle | AsyncTaskLoading<TData> | AsyncTaskSuccess<TData> | AsyncTaskError<TError>;
+/**
+ * A async task React Hook is a lightweight wrapper for an asynchronous function.
+ * It allows tracking of the task's execution status and provides access to the
+ * last error that occurred during the task's execution, if any.
+ *
+ * ```ts
+ * const [execute, { called, loading, data, error }]: UseAsyncTask<TData, TError, TInput> = useAnyAsyncTask();
+ *
+ * if (!called) {
+ *   // data === undefined
+ *   // error === undefined
+ *   return <p>Click the button to execute the task</p>;
+ * }
+ *
+ * if (loading) {
+ *   // data === undefined on first call
+ *   // data === TData from previous successful call
+ *   // error === undefined
+ *   return <Loader />;
+ * }
+ *
+ * if (error) {
+ *   // data === undefined
+ *   // error === TError
+ *   return <p>Something went wrong: {error.message}</p>;
+ * }
+ *
+ * // called === true
+ * // data === TData
+ * // error === undefined
+ * return <p>Task completed: {data}</p>;
+ * ```
+ */
+type UseAsyncTask<TInput, TValue, TError> = [
+    AsyncTask<TInput, ResultAsync<TValue, TError>>,
+    AsyncTaskState<TValue, TError>
+];
+
+/**
+ * The errors that could occur in the early stage of sending a transaction.
+ */
+type SendTransactionError = CancelError | SigningError | UnexpectedError;
+type CancelOperation = (message: string) => ResultAsync<never, CancelError>;
+type TransactionHandlerOptions = {
+    cancel: CancelOperation;
+};
+/**
+ * The errors that could occur in the late stages of a transaction.
+ */
+type PendingTransactionError = CancelError | TimeoutError | TransactionError | UnexpectedError;
+declare class PendingTransaction {
+    /**
+     * @internal Do NOT rely on this method. It's used internally by the SDK and may be subject to breaking changes.
+     */
+    readonly wait: () => ResultAsync<TransactionResult, PendingTransactionError>;
+    constructor(
+    /**
+     * @internal Do NOT rely on this method. It's used internally by the SDK and may be subject to breaking changes.
+     */
+    wait: () => ResultAsync<TransactionResult, PendingTransactionError>);
+    /**
+     * @internal
+     */
+    static ensure<T>(value: T): PendingTransaction & T;
+}
+type UseSendTransactionResult = UseAsyncTask<TransactionRequest, PendingTransaction, SendTransactionError>;
+/**
+ * The handler for sending Aave transactions.
+ */
+type TransactionHandler = (result: TransactionRequest | Erc20ApprovalRequired | PreContractActionRequired, options: TransactionHandlerOptions) => ResultAsync<PendingTransaction, SendTransactionError>;
+
+export { type AsyncTaskError as A, type CancelOperation as C, type PendingTransactionError as P, type SendTransactionError as S, type TransactionHandler as T, type UseSendTransactionResult as U, type UseAsyncTask as a, PendingTransaction as b, type AsyncTaskIdle as c, type AsyncTaskLoading as d, type AsyncTaskState as e, type AsyncTaskSuccess as f, type TransactionHandlerOptions as g };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aave/react",
-  "version": "4.0.0-next.1",
+  "version": "4.0.0-next.2",
   "description": "The official React bindings for the Aave Protocol",
   "keywords": [
     "aave",
@@ -72,10 +72,10 @@
   "sideEffects": false,
   "dependencies": {
     "urql": "^5.0.1",
-    "@aave/client": "4.0.0-next.1",
-    "@aave/core": "1.0.0-next.0",
-    "@aave/graphql": "1.0.0-next.1",
-    "@aave/types": "1.0.0-next.0"
+    "@aave/client": "4.0.0-next.2",
+    "@aave/core": "1.0.0-next.1",
+    "@aave/types": "1.0.0-next.1",
+    "@aave/graphql": "1.0.0-next.2"
   },
   "devDependencies": {
     "@privy-io/react-auth": "^2.20.0",