@1llet.xyz/erc4337-gasless-sdk 0.1.7 → 0.2.0

package/README.md

@@ -143,6 +143,39 @@ const address = await aa.getSmartAccountAddress(ownerAddress);
 const receipt = await aa.deployAccount();
 ```
 
+### Simplified Transactions (v0.2.0+)
+
+Send transactions without manually building, signing, and waiting.
+
+```typescript
+// 1. Send ETH or Call Contract (Single)
+const receipt = await aa.sendTransaction({
+    target: "0x123...",
+    value: 1000000000000000000n, // 1 ETH
+    data: "0x..." // Optional callData
+});
+
+// 2. Send Multiple Transactions (Batch)
+// Great for approving + swapping, or multiple transfers
+const receipt = await aa.sendBatchTransaction([
+    { target: "0xToken...", data: encodeApproveData },
+    { target: "0xSwap...", data: encodeSwapData }
+]);
+
+// 3. Transfer ERC-20 Tokens (Helper)
+// Automatically encodes the transfer call
+const receipt = await aa.transfer(
+    usdcAddress, 
+    recipientAddress, 
+    1000000n // 1 USDC
+);
+```
+
+### Error Decoding
+The SDK now automatically tries to decode cryptic "0x..." errors from the EntryPoint into readable messages like:
+- `Smart Account Error: Transfer amount exceeds balance`
+- `Smart Account: Native transfer failed`
+
 ### Simplified Approvals
 
 ```typescript

package/package.json

@@ -3,7 +3,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.1.7",
+    "version": "0.2.0",
     "description": "SDK for ERC-4337 Gasless Transfers",
     "main": "./dist/index.js",
     "module": "./dist/index.mjs",

package/src/AccountAbstraction.ts

@@ -7,7 +7,8 @@ import {
     type Address,
     type Hash,
     type Hex,
-    type PublicClient
+    type PublicClient,
+    decodeErrorResult
 } from "viem";
 import {
     factoryAbi,
@@ -452,6 +453,80 @@ export class AccountAbstraction {
         return await this.waitForUserOperation(hash);
     }
 
+    /**
+     * Send a single transaction via the Smart Account
+     * Abstracts: Build -> Sign -> Send -> Wait
+     */
+    async sendTransaction(
+        tx: { target: Address; value?: bigint; data?: Hex }
+    ): Promise<UserOpReceipt> {
+        return this.sendBatchTransaction([tx]);
+    }
+
+    /**
+     * Send multiple transactions via the Smart Account (Batched)
+     * Abstracts: Build -> Sign -> Send -> Wait
+     */
+    async sendBatchTransaction(
+        txs: { target: Address; value?: bigint; data?: Hex }[]
+    ): Promise<UserOpReceipt> {
+        // Normalize input (default value to 0, data to 0x)
+        const transactions = txs.map(tx => ({
+            target: tx.target,
+            value: tx.value ?? 0n,
+            data: tx.data ?? "0x"
+        }));
+
+        try {
+            const userOp = await this.buildUserOperationBatch(transactions);
+            const signed = await this.signUserOperation(userOp);
+            const hash = await this.sendUserOperation(signed);
+            return await this.waitForUserOperation(hash);
+        } catch (error) {
+            throw this.decodeError(error);
+        }
+    }
+
+    /**
+     * Try to decode meaningful errors from RPC or Revert data
+     */
+    private decodeError(error: any): Error {
+        const msg = error?.message || "";
+
+        // 1. Try to find hex data in the error message (UserOp Revert)
+        // Look for 0x... in "data": "0x..." or in the message itself
+        const hexMatch = msg.match(/(0x[0-9a-fA-F]+)/);
+
+        if (hexMatch) {
+            try {
+                // Try decoding as standard Error(string)
+                const decoded = decodeErrorResult({
+                    abi: [
+                        {
+                            inputs: [{ name: "message", type: "string" }],
+                            name: "Error",
+                            type: "error"
+                        },
+                        // Add common EntryPoint errors if known, but generic Reverts are most common
+                    ],
+                    data: hexMatch[0] as Hex
+                });
+
+                if (decoded.errorName === "Error") {
+                    return new Error(`Smart Account Error: ${decoded.args[0]}`);
+                }
+            } catch (e) {
+                // Failed to decode, stick to original
+            }
+        }
+
+        // 2. Common EntryPoint error mapping (simplified)
+        if (msg.includes("AA21")) return new Error("Smart Account: Native transfer failed (ETH missing?)");
+        if (msg.includes("AA25")) return new Error("Smart Account: Invalid account nonce");
+
+        return error instanceof Error ? error : new Error(String(error));
+    }
+
     /**
      * Approve a token for the Smart Account (EOA -> Token -> Smart Account)
      * Checks for gas sponsorship (Relayer funding) if needed.
@@ -495,6 +570,27 @@ export class AccountAbstraction {
         return "NOT_NEEDED";
     }
 
+    /**
+     * Transfer ERC-20 tokens from the Smart Account to a recipient
+     */
+    async transfer(
+        token: Address,
+        recipient: Address,
+        amount: bigint
+    ): Promise<UserOpReceipt> {
+        const data = encodeFunctionData({
+            abi: erc20Abi,
+            functionName: "transfer",
+            args: [recipient, amount]
+        });
+
+        return this.sendTransaction({
+            target: token,
+            value: 0n,
+            data
+        });
+    }
+
     // Getters
     getOwner(): Address | null {
         return this.owner;