Merge pull request #408 from LIT-Protocol/feature/drel-1208-aave-ability-for-multiple-smart-accounts

Aave ability for generic smart accounts

Author: FedericoAmura

docs/smart-account/abilities/aave-smart-account.mdx

@@ -116,20 +116,20 @@ This Ability's `precheck` function validates a UserOperation without actually si
        */
       userOp: {
         sender: string;                           // Smart Account address (hex)
-        nonce?: string;                           // Account nonce (hex string, e.g., "0x1")
+        nonce: string;                            // Account nonce (hex string, e.g., "0x1")
         callData: string;                         // Encoded transaction calls (hex)
-        callGasLimit?: string;                    // Gas limit for execution (hex)
-        verificationGasLimit?: string;            // Gas for verification (hex)
-        preVerificationGas?: string;              // Pre-verification gas (hex)
-        maxFeePerGas?: string;                    // Max fee per gas (hex, default: "0x59682F00")
-        maxPriorityFeePerGas?: string;            // Priority fee (hex, default: "0x3B9ACA00")
-        signature?: string;                       // Can be empty for precheck
+        callGasLimit: string;                     // Gas limit for execution (hex)
+        verificationGasLimit: string;             // Gas for verification (hex)
+        preVerificationGas: string;               // Pre-verification gas (hex)
+        maxFeePerGas: string;                     // Max fee per gas (hex, default: "0x59682F00")
+        maxPriorityFeePerGas: string;             // Priority fee (hex, default: "0x3B9ACA00")
+        signature?: string;                       // Can be empty
 
         // ERC-4337 v0.7.0 Paymaster fields (separate, not combined)
         paymaster?: string;                       // Paymaster address (hex)
         paymasterData?: string;                   // Paymaster-specific data (hex)
-        paymasterVerificationGasLimit?: string;   // Paymaster verification gas (hex)
-        paymasterPostOpGasLimit?: string;         // Paymaster post-op gas (hex)
+        paymasterVerificationGasLimit: string;    // Paymaster verification gas (hex)
+        paymasterPostOpGasLimit: string;          // Paymaster post-op gas (hex)
 
         // Account deployment fields (if account not yet deployed)
         factory?: string;                         // Account factory address (hex)
@@ -142,7 +142,7 @@ This Ability's `precheck` function validates a UserOperation without actually si
       /**
        * The Alchemy RPC URL for on-chain simulation and validation
        */
-      rpcUrl: string;
+      alchemyRpcUrl: string;
     }
     ```
 
@@ -192,7 +192,7 @@ This Ability's `precheck` function validates a UserOperation without actually si
         paymasterPostOpGasLimit: '0xC350', // Optional
       },
       entryPointAddress: '0x0000000071727De22E5E9d8baF0edAc6f37da032', // EntryPoint v0.7
-      rpcUrl: 'https://base-sepolia.g.alchemy.com/v2/YOUR_API_KEY',
+      alchemyRpcUrl: 'https://base-sepolia.g.alchemy.com/v2/YOUR_API_KEY',
     };
 
     const precheckResult = await abilityClient.precheck(smartAccountParams, {
@@ -202,9 +202,8 @@ This Ability's `precheck` function validates a UserOperation without actually si
     if (precheckResult.success) {
       console.log('UserOperation validation passed');
       // Result contains simulation changes and validated userOp
-      const { simulationChanges, userOp } = precheckResult.result;
+      const { simulationChanges } = precheckResult.result;
       console.log('Simulation changes:', simulationChanges);
-      console.log('Validated UserOp:', userOp);
     } else {
       // Handle different types of failures
       if (precheckResult.runtimeError) {
@@ -244,26 +243,6 @@ This Ability's `precheck` function validates a UserOperation without actually si
         name?: string | null;      // Token name
         logo?: string | null;      // Token logo URL
       }>;
-      /**
-       * The validated UserOperation (may be modified during validation)
-       */
-      userOp: {
-        sender: string;
-        nonce?: string;
-        callData: string;
-        callGasLimit?: string;
-        verificationGasLimit?: string;
-        preVerificationGas?: string;
-        maxFeePerGas?: string;
-        maxPriorityFeePerGas?: string;
-        signature?: string;
-        paymaster?: string;
-        paymasterData?: string;
-        paymasterVerificationGasLimit?: string;
-        paymasterPostOpGasLimit?: string;
-        factory?: string;
-        factoryData?: string;
-      };
     }
     ```
 
@@ -308,18 +287,18 @@ This Ability's `execute` function performs the same validation as precheck, then
         sender: string;
         nonce?: string;
         callData: string;
-        callGasLimit?: string;
-        verificationGasLimit?: string;
-        preVerificationGas?: string;
-        maxFeePerGas?: string;
-        maxPriorityFeePerGas?: string;
+        callGasLimit: string;
+        verificationGasLimit: string;
+        preVerificationGas: string;
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string;
         signature?: string;
 
         // v0.7.0 Paymaster fields
         paymaster?: string;
         paymasterData?: string;
-        paymasterVerificationGasLimit?: string;
-        paymasterPostOpGasLimit?: string;
+        paymasterVerificationGasLimit: string;
+        paymasterPostOpGasLimit: string;
 
         // Account deployment fields
         factory?: string;
@@ -332,19 +311,9 @@ This Ability's `execute` function performs the same validation as precheck, then
       /**
        * The Alchemy RPC URL for on-chain simulation and validation
        */
-      rpcUrl: string;
-      /**
-       * Serialized ZeroDev permission account (session key) that will sign the UserOperation
-       * This is the permitted signer configured on the Smart Account
-       */
-      serializedZeroDevPermissionAccount: string;
+      alchemyRpcUrl: string;
     }
     ```
-
-    **Important Notes:**
-    - `serializedZeroDevPermissionAccount` is **REQUIRED** for execute (not needed for precheck)
-    - This contains the session key configuration that authorizes the Agent Wallet to sign
-    - All other parameters are identical to `precheck`
   </Tab>
 
   <Tab title="Implementation">
@@ -355,21 +324,25 @@ This Ability's `execute` function performs the same validation as precheck, then
     const executeParams = {
       userOp: smartAccountParams.userOp,
       entryPointAddress: smartAccountParams.entryPointAddress,
-      rpcUrl: smartAccountParams.rpcUrl,
-      serializedZeroDevPermissionAccount: 'SERIALIZED_SESSION_KEY_HERE', // From ZeroDev session setup
+      alchemyRpcUrl: smartAccountParams.rpcUrl,
     };
 
     const executeResult = await abilityClient.execute(executeParams, {
       delegatorPkpEthAddress: '0x...', // Agent Wallet address
     });
 
     if (executeResult.success) {
-      const { simulationChanges, userOp } = executeResult.result;
+      const { simulationChanges, signature } = executeResult.result;
 
       console.log('UserOperation signed successfully');
-      console.log('Signature:', userOp.signature);
+      console.log('Signature:', signature);
       console.log('Simulation changes:', simulationChanges);
 
+      const userOp = {
+      ...smartAccountParams.userOp,
+        signature,
+      };
+
       // Now broadcast the signed UserOperation via your bundler
       const txHash = await bundler.sendUserOperation(userOp);
       console.log('Transaction hash:', txHash);
@@ -391,7 +364,7 @@ This Ability's `execute` function performs the same validation as precheck, then
   <Tab title="Response">
     **Success Response**
 
-    A successful `execute` response will contain the same structure as `precheck`, but with the UserOperation now signed:
+    A successful `execute` response will contain the same structure as `precheck`, but will add the signature:
 
     ```typescript
     {
@@ -413,25 +386,9 @@ This Ability's `execute` function performs the same validation as precheck, then
         logo?: string | null;
       }>;
       /**
-       * The signed UserOperation ready for broadcast
+       * The UserOperation signature by the PKP
        */
-      userOp: {
-        sender: string;
-        nonce?: string;
-        callData: string;
-        callGasLimit?: string;
-        verificationGasLimit?: string;
-        preVerificationGas?: string;
-        maxFeePerGas?: string;
-        maxPriorityFeePerGas?: string;
-        signature: string;           // ✅ Now contains valid signature
-        paymaster?: string;
-        paymasterData?: string;
-        paymasterVerificationGasLimit?: string;
-        paymasterPostOpGasLimit?: string;
-        factory?: string;
-        factoryData?: string;
-      };
+      signature: string;
     }
     ```
 
@@ -449,7 +406,7 @@ This Ability's `execute` function performs the same validation as precheck, then
     ```
 
     **Notes:**
-    - The response structure is identical to `precheck`, except `userOp.signature` is now populated
+    - The response structure is identical to `precheck`, except `signature` being added
     - The signed UserOperation can be broadcast directly to a bundler
     - `simulationChanges` provides the same asset change information
   </Tab>
@@ -475,10 +432,6 @@ Network support is limited by Alchemy's `alchemy_simulateUserOperationAssetChang
     This ability works with ERC-4337 compliant Smart Accounts. Ensure your Smart Account implementation follows the standard and has proper session key support.
   </Accordion>
 
-  <Accordion title="Session Key Setup" icon="key">
-    The Agent Wallet must be properly configured as a session key with appropriate permissions on the Smart Account. Without proper session key setup, signature validation will fail.
-  </Accordion>
-
   <Accordion title="Validation Strictness" icon="shield-check">
     The ability validates that ALL interactions are with authorized Aave contracts. Any unauthorized contract call will cause validation to fail. This is a security feature to prevent malicious operations.
   </Accordion>

packages/apps/ability-aave-smart-account/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@lit-protocol/vincent-ability-aave-smart-account",
-  "version": "0.0.9-mma",
+  "version": "1.0.2-mma",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "@bgd-labs/aave-address-book": "^4.19.3",
     "@lit-protocol/vincent-ability-sdk": "workspace:*",
-    "@zerodev/permissions": "^5.6.2",
-    "@zerodev/sdk": "^5.5.4",
     "tslib": "2.8.1",
     "viem": "^2.38.3",
     "zod": "^3.25.64"

packages/apps/ability-aave-smart-account/src/generated/lit-action.js

@@ -1,3 +1,3 @@
 {
-  "ipfsCid": "QmYtWuxxsUoRk59TxcN6Z1qHKWBmjiQESAhs6g3tNt7GUy"
+  "ipfsCid": "QmNNg7ygdUFDMqJC5GadYnLf26o5U6rDiPCmo1CuuoJWUt"
 }

packages/apps/ability-aave-smart-account/src/generated/vincent-ability-metadata.json

@@ -1 +1,8 @@
 export { bundledVincentAbility } from './generated/vincent-bundled-ability';
+export {
+  AAVE_POOL_ABI,
+  CHAIN_TO_AAVE_ADDRESS_BOOK,
+  getAaveAddresses,
+  getAvailableMarkets,
+  getATokens,
+} from './lib/helpers/aave';

packages/apps/ability-aave-smart-account/src/index.ts

@@ -115,7 +115,7 @@ export const AAVE_POOL_ABI: Abi = [
 /**
  * Chain id to Aave Address Book mapping
  */
-const CHAIN_TO_AAVE_ADDRESS_BOOK: Record<number, any> = {
+export const CHAIN_TO_AAVE_ADDRESS_BOOK: Record<number, any> = {
   // Mainnets
   1: AaveV3Ethereum,
   137: AaveV3Polygon,

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

@@ -1,5 +1,5 @@
-import { KernelV3_3AccountAbi } from '@zerodev/sdk';
 import {
+  type Abi,
   type Address,
   type Hex,
   decodeAbiParameters,
@@ -16,17 +16,87 @@ import { UserOp } from './userOperation';
 
 type LowLevelCall = { to: Address; value: bigint; data: Hex };
 
+// A big unified ABI of different smart account implementations
+const smartAccountsAbi: Abi = [
+  // Kernel v3.3/v3.1/v3.0
+  {
+    type: 'function',
+    name: 'execute',
+    inputs: [
+      { name: 'execMode', type: 'bytes32', internalType: 'ExecMode' },
+      { name: 'executionCalldata', type: 'bytes', internalType: 'bytes' },
+    ],
+    outputs: [],
+    stateMutability: 'payable',
+  },
+  {
+    type: 'function',
+    name: 'executeFromExecutor',
+    inputs: [
+      { name: 'execMode', type: 'bytes32', internalType: 'ExecMode' },
+      { name: 'executionCalldata', type: 'bytes', internalType: 'bytes' },
+    ],
+    outputs: [{ name: 'returnData', type: 'bytes[]', internalType: 'bytes[]' }],
+    stateMutability: 'payable',
+  },
+  {
+    type: 'function',
+    name: 'executeUserOp',
+    inputs: [
+      {
+        name: 'userOp',
+        type: 'tuple',
+        internalType: 'struct PackedUserOperation',
+        components: [
+          {
+            name: 'sender',
+            type: 'address',
+            internalType: 'address',
+          },
+          { name: 'nonce', type: 'uint256', internalType: 'uint256' },
+          { name: 'initCode', type: 'bytes', internalType: 'bytes' },
+          { name: 'callData', type: 'bytes', internalType: 'bytes' },
+          {
+            name: 'accountGasLimits',
+            type: 'bytes32',
+            internalType: 'bytes32',
+          },
+          {
+            name: 'preVerificationGas',
+            type: 'uint256',
+            internalType: 'uint256',
+          },
+          {
+            name: 'gasFees',
+            type: 'bytes32',
+            internalType: 'bytes32',
+          },
+          {
+            name: 'paymasterAndData',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+          { name: 'signature', type: 'bytes', internalType: 'bytes' },
+        ],
+      },
+      { name: 'userOpHash', type: 'bytes32', internalType: 'bytes32' },
+    ],
+    outputs: [],
+    stateMutability: 'payable',
+  },
+];
+
 function isDelegatecallOrUnknown(execMode: Hex): boolean {
   const lastByte = BigInt(execMode) & 0xffn;
   return lastByte !== 0n; // 0x00 == CALL; others => block
 }
 
 function tryDecodeExecute(executionCalldata: Hex): LowLevelCall[] | null {
-  // Because Execute with a single call is just an hex concatenation of the calldata,
-  // this function might produce invalid decodings. It MUST be called last, only if
-  // all other, more strict, decodings failed or if we know the calldata is a single call.
-  // Also, current implementation does not support delegate calls, it will produce
-  // invalid decodings for them.
+  // Because Execute with a single call is just a hex concatenation of the calldata,
+  // this function might produce invalid decoding. It MUST be called last, only if
+  // all other, stricter, decodings failed or if we know the calldata is a single call.
+  // Also, the current implementation does not support delegate calls. It will produce
+  // an invalid decoding for them.
   try {
     const hex = executionCalldata.slice(2);
     const MIN = 20 * 2 + 32 * 2; // address + value
@@ -87,7 +157,7 @@ function tryDecodeBatchWithValues(executionCalldata: Hex): LowLevelCall[] | null
 }
 
 function decodeKernelV33ToCalls(callData: Hex): LowLevelCall[] {
-  const df = decodeFunctionData({ abi: KernelV3_3AccountAbi, data: callData });
+  const df = decodeFunctionData({ abi: smartAccountsAbi, data: callData });
   if (df.functionName !== 'execute' && df.functionName !== 'executeFromExecutor') {
     throw new Error('Not a Kernel v3.3 execute/executor call');
   }