Aave ability for smart accounts (#351)

* feat: initial implementation with precheck of aave ability for smart accounts using alchemys light account as model

* fix: make rpc url required

* feat: execute method with signing for tested user operation

* fix: pnpm lockfile

* feat: remove unused libraries and organize code

* fix: pkp user op signature handling

* fix: tests configuration

* fix: more tests configuration

* fix: get user operation version based on the entrypoint address

* feat: make initCode mandatory for non-initialized accounts to avoid restricting support for specific implementations

* fix: lines with expected typescript errors in tests

* feat: move simulateUserOp

* fix: hex regex filtering values that had uppercase chars

* feat: use static json rpc providers

* feat: update ability to sign for zerodev v3.3 smart accounts after passing userop calldata decoding and simulation validations

* feat: update pnpm lockfile

* fix: remove ethers dependency on aave smart accounts ability

* feat: update lockfile

* fix: pass test when there are none

* feat: update lockfile after merge

* fix: bundled transactions in user operation decoding

* feat: explicitly define alchemy rpc url

* feat: add utilities to simulate eoa transactions

* fix: build and publish latest version

* feat: ensure alchemy rpc url is from alchemy and not a fake one controlled by the user

* chore: merge main, run pnpm i

* Update packages/apps/ability-aave-smart-account/scripts/deploy-lit-action.js

Co-authored-by: Copilot <[email protected]>

* Update packages/apps/ability-aave-smart-account/src/lib/helpers/aave.ts

Co-authored-by: Copilot <[email protected]>

* fix: remove duplicate user

---------

Co-authored-by: Chris Cassano <[email protected]>
Co-authored-by: Chris Cassano <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: 3 people

packages/apps/ability-aave-smart-account/.env.example

@@ -0,0 +1,4 @@
+**/**/vincent-contract-caller-config.json
+!.env.test.example
+test/test-config.json
+#src/generated/**/*

packages/apps/ability-aave-smart-account/.env.test.example

@@ -0,0 +1,90 @@
+# Contributing to Vincent Ability Aave for Smart Account (EIP-4337)
+
+This document provides guidelines for contributing to the Vincent Ability Aave project.
+
+## Overview
+
+The Vincent Ability Aave is a ability to send deposit, withdraw or redeem Aave transactions from a Vincent app on behalf of the delegator. It's part of the Vincent Abilities ecosystem and is built using the Vincent Ability SDK.
+
+## Setup
+
+1. Follow the global setup instructions in the repository root [CONTRIBUTING.md](../../../CONTRIBUTING.md).
+2. Install dependencies:
+   ```bash
+   pnpm install
+   ```
+
+## Development Workflow
+
+### Testing
+
+Run tests:
+
+```bash
+nx test ability-aave-smart-account
+```
+
+### Building the Lit Action
+
+Build the ability:
+
+```bash
+nx action:build ability-aave-smart-account
+```
+
+### Deploying the Lit Action to IPFS
+
+Building will be done automatically. Deploy the ability:
+
+```bash
+nx action:deploy ability-aave-smart-account
+```
+
+## Project Structure
+
+- `src/`: Source code
+  - `index.ts`: Main entry point
+
+## Ability Development Guidelines
+
+1. Use the Vincent Ability SDK to create abilities
+2. Define clear schemas for ability parameters
+3. Implement the ability lifecycle methods (precheck, execute)
+4. Handle errors gracefully
+5. Write comprehensive tests for all functionality
+6. Document the ability's purpose and usage
+
+## Integration with Policies
+
+This ability can be integrated with various Vincent Policies to enforce constraints. When developing or modifying the ability, consider how it will be used with policies such as:
+
+- Vincent Policy Spending Limit
+
+## Testing
+
+Write unit tests for all functionality:
+
+```bash
+pnpm test
+```
+
+## Documentation
+
+- Document the ability's purpose and usage
+- Update README.md when adding new features
+- Document the ability's parameters and behavior
+
+## Pull Request Process
+
+1. Ensure your code follows the coding standards
+2. Update documentation if necessary
+3. Include tests for new functionality
+4. Link any related issues in your pull request description
+5. Request a review from a maintainer
+
+## Additional Resources
+
+- [Vincent Documentation](https://docs.heyvincent.ai/)
+- [Vincent Ability SDK Documentation](../../libs/ability-sdk/README.md)
+- [ERC20 Standard](https://eips.ethereum.org/EIPS/eip-20)
+- [ERC4626 Standard](https://eips.ethereum.org/EIPS/eip-4626)

packages/apps/ability-aave-smart-account/.gitignore

@@ -0,0 +1,114 @@
+# Vincent Aave Ability for Smart Accounts (EIP-4337)
+
+# TODO update this and other docs
+
+A comprehensive DeFi ability for interacting with Aave v3 protocol on Ethereum, built for the Vincent
+Scaffold SDK and Lit Actions execution environment.
+
+## Overview
+
+The Vincent Aave Ability enables secure, decentralized interactions with the Aave v3 lending protocol
+through Lit Actions. It supports all core Aave operations: supplying assets as collateral, borrowing
+against collateral, repaying debt, and withdrawing assets.
+
+## Features
+
+- Supply assets as collateral to earn interest
+- Withdraw supplied assets
+- Borrow against collateral with stable or variable rates
+- Repay borrowed assets
+- Multi-chain support (Ethereum, Polygon, Arbitrum, Optimism, Base, and more)
+- Integrated with Vincent Ability SDK for secure execution
+
+## Installation
+
+```bash
+npm install @lit-protocol/vincent-ability-aave
+```
+
+## Usage
+
+```typescript
+import { getVincentAbilityClient } from '@lit-protocol/vincent-app-sdk';
+import { bundledVincentAbility as aaveAbility } from '@lit-protocol/vincent-ability-aave-smart-account';
+
+// Initialize the ability client
+const aaveAbilityClient = getVincentAbilityClient({
+  bundledVincentAbility: aaveAbility,
+  ethersSigner: yourSigner, // Your ethers signer
+});
+
+// Example: Supply WETH as collateral
+const supplyParams = {
+  operation: 'supply',
+  asset: '0xC558DBdd856501FCd9aaF1E62eae57A9F0629a3c', // WETH on Sepolia
+  amount: '0.01',
+  chain: 'sepolia',
+};
+
+// First run precheck
+const precheckRes = await aaveAbilityClient.precheck(supplyParams, {
+  delegatorPkpEthAddress: pkpAddress,
+});
+
+if (precheckRes.success) {
+  // Then execute
+  const executeRes = await aaveAbilityClient.execute(supplyParams, {
+    delegatorPkpEthAddress: pkpAddress,
+  });
+
+  if (executeRes.success) {
+    console.log('Transaction hash:', executeRes.result.data.txHash);
+  }
+}
+```
+
+## Parameters
+
+| Parameter          | Type                                            | Required | Description                                      |
+| ------------------ | ----------------------------------------------- | -------- | ------------------------------------------------ |
+| `operation`        | `"supply" \| "withdraw" \| "borrow" \| "repay"` | ✅       | The Aave operation to perform                    |
+| `asset`            | `string`                                        | ✅       | Token contract address (0x format)               |
+| `amount`           | `string`                                        | ✅       | Amount as a string (e.g., "1.5")                 |
+| `chain`            | `string`                                        | ✅       | Chain identifier (e.g., "ethereum", "polygon")   |
+| `interestRateMode` | `1 \| 2`                                        | ❌       | 1=Stable, 2=Variable (required for borrow/repay) |
+| `rpcUrl`           | `string`                                        | ❌       | Custom RPC URL for precheck validation           |
+
+## Prerequisites
+
+- Node.js 16+ and npm/yarn
+- Sufficient token balance for the operation
+- Token approval for supply/repay operations
+- Properly configured PKP wallet with required permissions
+
+## Building
+
+```bash
+# Build the ability
+npm run build
+
+# Build all abilitys and policies
+npm run vincent:build
+```
+
+## Testing
+
+```bash
+# Run unit tests
+npm test
+
+# Run E2E tests
+npm run test:e2e
+
+# Reset test state
+npm run test:reset
+```
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](../../CONTRIBUTING.md) for guidelines on how
+to contribute to this project.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details.

packages/apps/ability-aave-smart-account/CONTRIBUTING.md

@@ -0,0 +1,2 @@
+const denoFetch = (...args) => globalThis.fetch(...args);
+export default denoFetch;

packages/apps/ability-aave-smart-account/README.md

@@ -0,0 +1,171 @@
+const fs = require('fs');
+const path = require('path');
+
+const esbuild = require('esbuild');
+const { polyfillNode } = require('@lit-protocol/esbuild-plugin-polyfill-node');
+const Hash = require('ipfs-only-hash');
+
+function aliasFetch() {
+  const shim = path.resolve(__dirname, 'deno-fetch-shim.js');
+
+  return {
+    name: 'alias-fetch',
+    setup(build) {
+      build.onResolve({ filter: /^node-fetch$/ }, () => ({ path: shim }));
+      build.onResolve({ filter: /^cross-fetch(\/.*)?$/ }, () => ({ path: shim }));
+    },
+  };
+}
+
+const ensureDirectoryExistence = (filePath) => {
+  const dirname = path.dirname(filePath);
+  if (!fs.existsSync(dirname)) {
+    fs.mkdirSync(dirname, { recursive: true });
+  }
+};
+
+function getBundledVincentAbilityCode() {
+  return `/**
+ * DO NOT EDIT THIS FILE. IT IS GENERATED ON BUILD.
+ */
+
+import { asBundledVincentAbility } from '@lit-protocol/vincent-ability-sdk';
+import { vincentAbility } from '../lib/vincent-ability';
+import metadata from './vincent-ability-metadata.json';
+
+if(!metadata.ipfsCid) {
+  throw new Error('ipfsCid is not defined in metadata JSON file');
+}
+
+export const bundledVincentAbility = asBundledVincentAbility(vincentAbility, metadata.ipfsCid);
+`;
+}
+
+function litActionModuleCode({ ipfsCid, content }) {
+  return `/**
+ * DO NOT EDIT THIS FILE. IT IS GENERATED ON BUILD.
+ * @type {string}
+ */
+const code = ${JSON.stringify(content)};
+module.exports = {
+  "code": code,
+  "ipfsCid": "${ipfsCid}",
+};
+`;
+}
+
+function metadataJsonFile({ ipfsCid }) {
+  return `{
+  "ipfsCid": "${ipfsCid}"
+}
+`;
+}
+
+const createBundledAbilityFile = {
+  name: 'create-vincent-bundled-ability-file',
+  setup(build) {
+    build.initialOptions.write = false;
+
+    const sourceDir = path.dirname(build.initialOptions.entryPoints[0]);
+
+    console.log(sourceDir);
+    build.onEnd(async (result) => {
+      if (result.errors.length > 0) {
+        console.error('Build failed with errors:', result.errors);
+        return;
+      }
+
+      const outputFile = result.outputFiles[0];
+      const content = outputFile.text;
+      const ipfsCid = await Hash.of(content);
+
+      // Write bundledAbility wrapper
+      const bundledSource = getBundledVincentAbilityCode();
+      const bundledPath = path.join(sourceDir, '../generated/vincent-bundled-ability.ts');
+      fs.writeFileSync(bundledPath, bundledSource);
+
+      // Write metadata JSON
+      const outputPath = path.dirname(path.resolve(outputFile.path));
+      const metadataPath = path.join(outputPath, 'vincent-ability-metadata.json');
+      const metadataContent = metadataJsonFile({ ipfsCid });
+      fs.writeFileSync(metadataPath, metadataContent);
+    });
+  },
+};
+
+const wrapIIFEInStringPlugin = {
+  name: 'wrap-iife-in-string',
+  setup(build) {
+    build.initialOptions.write = false;
+
+    build.onEnd(async (result) => {
+      if (result.errors.length > 0) {
+        console.error('Build failed with errors:', result.errors);
+        return;
+      }
+
+      const outputFile = result.outputFiles[0];
+      const content = outputFile.text;
+      const ipfsCid = await Hash.of(content);
+
+      const wrapped = litActionModuleCode({ content, ipfsCid });
+      const outputPath = path.resolve(outputFile.path);
+      ensureDirectoryExistence(outputPath);
+      fs.writeFileSync(outputPath, wrapped);
+    });
+  },
+};
+
+(async () => {
+  try {
+    await esbuild
+      .build({
+        tsconfig: './tsconfig.lib.json',
+        entryPoints: ['./src/lib/lit-action.ts'],
+        bundle: true,
+        minify: false,
+        sourcemap: false,
+        treeShaking: true,
+        metafile: true,
+        outdir: './src/generated/',
+        plugins: [
+          aliasFetch(),
+          polyfillNode({
+            globals: {
+              Buffer: true,
+              process: true,
+            },
+            modules: {
+              crypto: true,
+              http: true,
+              https: true,
+              stream: true,
+              zlib: true,
+              url: true,
+              util: true,
+            },
+          }),
+          wrapIIFEInStringPlugin,
+          createBundledAbilityFile,
+        ],
+        platform: 'browser',
+        write: false,
+      })
+      .then((result) => {
+        result.outputFiles.forEach((file) => {
+          const bytes = file.text.length;
+          const mbInBinary = (bytes / (1024 * 1024)).toFixed(4);
+          const mbInDecimal = (bytes / 1_000_000).toFixed(4);
+
+          console.log(
+            `✅ ${file.path.split('/').pop()}\n- ${mbInDecimal} MB (in decimal)\n- ${mbInBinary} MB (in binary)`,
+          );
+        });
+      });
+
+    console.log('✅ Vincent ability built successfully');
+  } catch (e) {
+    console.error('❌ Error building Vincent ability: ', e);
+    process.exit(1);
+  }
+})();