Smart Wallets with Aave

import { LocalAccountSigner } from "@aa-sdk/core";
import { createModularAccountAlchemyClient } from "@account-kit/smart-contracts";
import { alchemy } from "@account-kit/infra";
import { reserve, supply, withdraw } from "@aave/client/actions";
import {
  currentChain,
  getCurrentTokenAddress,
  getCurrentAavePoolAddress,
  config,
} from "./config";
 
// Supply assets to Aave
async function executeSupply() {
  const alchemyApiKey = process.env.ALCHEMY_API_KEY!;
  const privateKey = process.env.PRIVATE_KEY! as `0x${string}`;
  const policyId = process.env.PAYMASTER_POLICY_ID! as `0x${string}`;
 
  // Setup signer
  const signer = LocalAccountSigner.privateKeyToAccountSigner(privateKey);
 
  // Create smart account client with gas sponsorship
  const smartAccountClient = await createModularAccountAlchemyClient({
    transport: alchemy({ apiKey: alchemyApiKey }),
    policyId, // Enables gas sponsorship
    chain: currentChain,
    signer,
  });
 
  const accountAddress = smartAccountClient.account.address;
 
  // Get reserve data from Aave
  const reserveDataResult = await reserve(client, {
    market: evmAddress(getCurrentAavePoolAddress()),
    underlyingToken: evmAddress(getCurrentTokenAddress()),
    chainId: chainId(currentChain.id),
    user: accountAddress,
  });
 
  const reserveData = reserveDataResult.value;
 
  // Get supply transaction data
  const supplyResult = await supply(client, {
    market: reserveData.market.address,
    amount: {
      erc20: {
        currency: reserveData.underlyingToken.address,
        value: config.amounts.deposit,
      },
    },
    sender: evmAddress(accountAddress),
    chainId: reserveData.market.chain.chainId,
  });
 
  let supplyData = supplyResult.value;
 
  // Handle transactions (approval + supply or just supply)
  if (supplyData.__typename === "ApprovalRequired") {
    // Send approval transaction
    const approvalTx = await smartAccountClient.sendUserOperation({
      account: smartAccountClient.account,
      uo: {
        target: supplyData.approval.to,
        data: supplyData.approval.data,
      },
    });
 
    await smartAccountClient.getUserOperationReceipt(approvalTx.hash);
 
    // Send supply transaction
    const supplyTx = await smartAccountClient.sendUserOperation({
      account: smartAccountClient.account,
      uo: {
        target: supplyData.originalTransaction.to,
        data: supplyData.originalTransaction.data,
        value: BigInt(supplyData.originalTransaction.value),
      },
    });
 
    console.log("Supply completed! Hash:", supplyTx.hash);
  }
}
 
// Withdraw assets from Aave
async function executeWithdraw() {
  // Setup same as supply...
  const smartAccountClient = await createModularAccountAlchemyClient({
    transport: alchemy({ apiKey: alchemyApiKey }),
    policyId,
    chain: currentChain,
    signer,
  });
 
  // Get withdraw transaction data
  const withdrawResult = await withdraw(client, {
    market: reserveData.market.address,
    amount: {
      erc20: {
        currency: reserveData.underlyingToken.address,
        value: { exact: config.amounts.withdraw }, // or { max: true } for all
      },
    },
    sender: evmAddress(accountAddress),
    chainId: reserveData.market.chain.chainId,
  });
 
  let withdrawData = withdrawResult.value;
 
  if (withdrawData.__typename === "TransactionRequest") {
    const withdrawTx = await smartAccountClient.sendUserOperation({
      account: smartAccountClient.account,
      uo: {
        target: withdrawData.to,
        data: withdrawData.data,
        value: BigInt(withdrawData.value),
      },
    });
 
    console.log("Withdrawal completed! Hash:", withdrawTx.hash);
  }
}