feat: implements sendWith helpers for ethers and viem

Author: cesarenaldi

packages/client/src/ethers.ts

@@ -1 +1,71 @@
-export {};
+import type {
+  ExecutionPlan,
+  InsufficientBalanceError,
+  TransactionRequest,
+} from '@aave/graphql';
+import {
+  errAsync,
+  invariant,
+  nonNullable,
+  ResultAsync,
+  type TxHash,
+  txHash,
+} from '@aave/types';
+import type { Signer, TransactionResponse } from 'ethers';
+import { SigningError, ValidationError } from './errors';
+import type { ExecutionPlanHandler } from './types';
+
+async function sendTransaction(
+  signer: Signer,
+  request: TransactionRequest,
+): Promise<TransactionResponse> {
+  return signer.sendTransaction({
+    to: request.to,
+    data: request.data,
+    value: request.value,
+    from: request.from,
+  });
+}
+
+/**
+ * @internal
+ */
+export function sendTransactionAndWait(
+  signer: Signer,
+  request: TransactionRequest,
+): ResultAsync<TxHash, SigningError> {
+  return ResultAsync.fromPromise(sendTransaction(signer, request), (err) =>
+    SigningError.from(err),
+  )
+    .map((tx) => tx.wait())
+    .map((receipt) => txHash(nonNullable(receipt?.hash)));
+}
+
+/**
+ * Sends transactions using the provided ethers signer.
+ *
+ * Handles {@link TransactionRequest} by signing and sending, {@link ApprovalRequired} by sending both approval and original transactions, and returns validation errors for {@link InsufficientBalanceError}.
+ */
+export function sendWith(signer: Signer | undefined): ExecutionPlanHandler {
+  return (
+    result: ExecutionPlan,
+  ): ResultAsync<
+    TxHash,
+    SigningError | ValidationError<InsufficientBalanceError>
+  > => {
+    invariant(signer, 'Expected a Signer to handle the operation result.');
+
+    switch (result.__typename) {
+      case 'TransactionRequest':
+        return sendTransactionAndWait(signer, result);
+
+      case 'ApprovalRequired':
+        return sendTransactionAndWait(signer, result.approval).andThen(() =>
+          sendTransactionAndWait(signer, result.originalTransaction),
+        );
+
+      case 'InsufficientBalanceError':
+        return errAsync(ValidationError.fromGqlNode(result));
+    }
+  };
+}

packages/client/src/types.ts

@@ -1,10 +1,10 @@
-import type { ExecutionPlan, TransactionRequest } from '@aave/graphql';
+import type { ExecutionPlan, InsufficientBalanceError } from '@aave/graphql';
 import type { ResultAsync, TxHash } from '@aave/types';
 import type { SigningError, ValidationError } from './errors';
 
-export type OperationHandler<T extends ExecutionPlan = ExecutionPlan> = (
+export type ExecutionPlanHandler<T extends ExecutionPlan = ExecutionPlan> = (
   result: T,
 ) => ResultAsync<
   TxHash,
-  SigningError | ValidationError<Exclude<T, TransactionRequest>>
+  SigningError | ValidationError<InsufficientBalanceError>
 >;

packages/client/src/viem.ts

@@ -1 +1,93 @@
-export {};
+import type {
+  ExecutionPlan,
+  InsufficientBalanceError,
+  TransactionRequest,
+} from '@aave/graphql';
+import {
+  errAsync,
+  invariant,
+  ResultAsync,
+  type TxHash,
+  txHash,
+} from '@aave/types';
+import type { Hash, WalletClient } from 'viem';
+import {
+  sendTransaction as sendEip1559Transaction,
+  waitForTransactionReceipt,
+} from 'viem/actions';
+import { SigningError, ValidationError } from './errors';
+import type { ExecutionPlanHandler } from './types';
+
+async function sendTransaction(
+  walletClient: WalletClient,
+  request: TransactionRequest,
+): Promise<Hash> {
+  return sendEip1559Transaction(walletClient, {
+    account: request.from,
+    data: request.data,
+    to: request.to,
+    value: BigInt(request.value),
+    chain: request.chainId,
+  });
+}
+
+/**
+ * @internal
+ */
+export function sendTransactionAndWait(
+  walletClient: WalletClient,
+  request: TransactionRequest,
+): ResultAsync<TxHash, SigningError> {
+  return ResultAsync.fromPromise(
+    sendTransaction(walletClient, request),
+    (err) => SigningError.from(err),
+  )
+    .map(async (hash) =>
+      waitForTransactionReceipt(walletClient, {
+        hash,
+        pollingInterval: 100,
+        retryCount: 20,
+        retryDelay: 50,
+      }),
+    )
+    .map((receipt) => txHash(receipt.transactionHash));
+}
+
+/**
+ * Sends transactions using the provided wallet client.
+ *
+ * Handles {@link TransactionRequest} by signing and sending, {@link ApprovalRequired} by sending both approval and original transactions, and returns validation errors for {@link InsufficientBalanceError}.
+ */
+export function sendWith(
+  walletClient: WalletClient | undefined,
+): ExecutionPlanHandler {
+  return (
+    result: ExecutionPlan,
+  ): ResultAsync<
+    TxHash,
+    SigningError | ValidationError<InsufficientBalanceError>
+  > => {
+    if ('hash' in result) {
+      return okAsync(result.hash);
+    }
+
+    invariant(
+      walletClient,
+      'Expected a WalletClient to handle the operation result.',
+    );
+
+    switch (result.__typename) {
+      case 'TransactionRequest':
+        return sendTransactionAndWait(walletClient, result);
+
+      case 'ApprovalRequired':
+        return sendTransactionAndWait(walletClient, result.approval).andThen(
+          () =>
+            sendTransactionAndWait(walletClient, result.originalTransaction),
+        );
+
+      case 'InsufficientBalanceError':
+        return errAsync(ValidationError.fromGqlNode(result));
+    }
+  };
+}