@dag-kit/kit 1.0.0 → 1.0.4-alpha.3

package/src/clients/actions/index.ts

@@ -0,0 +1,145 @@
+// import {
+//   createPublicClient,
+//   createWalletClient,
+//   encodeFunctionData,
+//   formatEther,
+//   http,
+//   parseEther,
+//   parseGwei,
+// } from "viem";
+// import { awakening } from "../chains";
+// import { privateKeyToAccount } from "viem/accounts";
+// import { entryPoint06Address } from "viem/account-abstraction";
+// import { toSimpleSmartAccount } from "permissionless/accounts";
+// import { createSmartAccountClient } from "permissionless";
+// import { createPimlicoClient } from "permissionless/clients/pimlico";
+// import { abi } from "./contract";
+
+// const { bundler_rpc, chain_config } = awakening;
+// const FACTORY_ADDRESS = "0x8FaB6DF00085eb05D5F2C1FA46a6E539587ae3f3";
+// const adminKey =
+//   "0x6b0f66a03b67d7b9eaa6c31123ffe5bf2ee58eb40ab86c8a14d6f1294838b0c8";
+
+// const publicClient = createPublicClient({
+//   chain: awakening.chain_config,
+//   transport: http(awakening.chain_config.rpcUrls.default.http[0]),
+// });
+
+// const walletClient = createWalletClient({
+//   account: privateKeyToAccount(adminKey),
+//   chain: chain_config,
+//   transport: http(chain_config.rpcUrls.default.http[0]),
+// });
+
+// const account = await toSimpleSmartAccount({
+//   client: publicClient,
+//   owner: privateKeyToAccount(adminKey),
+//   factoryAddress: FACTORY_ADDRESS,
+//   entryPoint: {
+//     address: entryPoint06Address,
+//     version: "0.6",
+//   },
+//   index: 100n,
+// });
+
+// console.log("Account Address: %s", account.address);
+// // Check if account is deployed
+// let code = await publicClient.getCode({
+//   address: account.address,
+// });
+
+// let isDeployed = code && code !== "0x";
+// console.log(
+//   `Deployment Status: ${isDeployed ? "✅ Deployed" : "⚠️ Not deployed"}`
+// );
+
+// if (!isDeployed) {
+//   const fundTx = await walletClient.sendTransaction({
+//     to: account.address,
+//     value: parseEther("10"),
+//     chain: undefined,
+//   });
+
+//   await publicClient.waitForTransactionReceipt({
+//     hash: fundTx,
+//     timeout: 120_000,
+//     pollingInterval: 5_000,
+//   });
+//   console.log("Account funded");
+// }
+
+// console.log("\n==== Sending Test UserOperation =====");
+// const cd = encodeFunctionData({
+//   abi,
+//   functionName: "increment",
+//   args: [],
+// });
+
+// const smartAccountClient = createSmartAccountClient({
+//   bundlerTransport: http(bundler_rpc),
+//   chain: awakening,
+//   account,
+// });
+
+// // Simple test: send 0 ETH to self (just to test the flow)
+// try {
+//   // Get current gas prices from the bundler
+//   const dagClient = createPimlicoClient({
+//     transport: http(bundler_rpc),
+//     entryPoint: {
+//       address: entryPoint06Address,
+//       version: "0.6",
+//     },
+//   });
+
+//   const balance = await publicClient.getBalance({
+//     address: account.address,
+//   });
+//   const balanceInETH = Number(balance) / 1e18;
+
+//   const gasPrices = await dagClient.getUserOperationGasPrice();
+//   console.log("Using gas prices:", gasPrices.fast);
+
+//   const SAFE_GAS_PRICE = parseGwei("50"); // 100 Gwei
+
+//   console.log("SAFE gas prices:", formatEther(SAFE_GAS_PRICE));
+
+//   const txHash = await smartAccountClient.sendTransaction({
+//     to: "0x8FaB6DF00085eb05D5F2C1FA46a6E539587ae3f3", // Send to self
+//     value: 0n,
+//     data: cd,
+//     maxFeePerGas: SAFE_GAS_PRICE,
+//     maxPriorityFeePerGas: SAFE_GAS_PRICE,
+//     // Keep your high limits
+//     callGasLimit: 150000n,
+//     verificationGasLimit: 500000n, // Bumped for safety
+//     preVerificationGas: 100000n,
+//   });
+
+//   console.log(`\n✅ Success!`);
+//   console.log(`UserOperation Hash: ${txHash}`);
+//   console.log(`Transaction: https://awakening.bdagscan.com/tx/${txHash}`);
+
+//   // Wait a moment for the transaction to be included
+//   console.log("\nWaiting for transaction to be mined...");
+//   await new Promise((resolve) => setTimeout(resolve, 5000));
+
+//   const newBalance = await publicClient.getBalance({
+//     address: account.address,
+//   });
+//   const newBalanceInETH = Number(newBalance) / 1e18;
+//   console.log(`\nFinal Balance: ${newBalanceInETH} ETH`);
+//   console.log(`Gas Cost: ${balanceInETH - newBalanceInETH} ETH`);
+
+//   console.log("\n🎉 Account Abstraction is working on Awakening!");
+//   console.log(
+//     "This proves your setup is correct - the issue is specific to Awakening testnet."
+//   );
+// } catch (error: any) {
+//   console.error("\n❌ Transaction failed:");
+//   console.error(error.message);
+
+//   if (error.details) {
+//     console.error("\nDetails:", error.details);
+//   }
+// }

package/src/clients/actions/main.ts

@@ -14,6 +14,8 @@ import {
   type Address,
   encodeFunctionData,
   parseEther,
+  Client,
+  ByteArray,
 } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 import { toSimpleSmartAccount } from "permissionless/accounts";
@@ -25,7 +27,8 @@ import {
   SmartAccountConfig,
   SendUserOperationParams,
   UserOperationReceipt,
-} from "../types";
+} from "../types.js";
+import { ISigner } from "../../signers/types.js";
 
 // ==============================================================================
 // Main SDK Class
@@ -33,13 +36,12 @@ import {
 
 export class DagAAClient {
   private config: DagAAConfig;
-  private publicClient: ReturnType<typeof createPublicClient>;
-  private walletClient: ReturnType<typeof createWalletClient>;
-  private bundlerClient: ReturnType<typeof createPimlicoClient> | null = null;
+  private publicClient: any | null;
+  private walletClient: any | null;
+  private bundlerClient: any | null = null;
   private smartAccount: any | null = null;
-  private smartAccountClient: ReturnType<
-    typeof createSmartAccountClient
-  > | null = null;
+  private paymasterClient: any | null = null;
+  private smartAccountClient: any | null = null;
 
   constructor(config: DagAAConfig) {
     this.config = {
@@ -56,8 +58,112 @@ export class DagAAClient {
       chain: config.chain,
       transport: http(config.rpcUrl),
     });
+
+    // Initialize paymaster client if URL provided
+    if (config.paymasterUrl) {
+      this.paymasterClient = this.createPaymasterClient(config.paymasterUrl);
+    }
   }
+  // ==============================================================================
+  // Paymaster Client (Fixed Serialization)
+  // ==============================================================================
+
+  private createPaymasterClient(paymasterUrl: string) {
+    // 1. Define a robust serializer that handles nested BigInts automatically
+    const stringify = (data: any) => {
+      return JSON.stringify(data, (_, value) =>
+        typeof value === "bigint" ? `0x${value.toString(16)}` : value
+      );
+    };
+
+    return {
+      /**
+       * Get paymaster stub data for gas estimation
+       */
+      async getPaymasterStubData(
+        userOp: any,
+        entryPoint: Address
+      ): Promise<any> {
+        try {
+          const response = await fetch(paymasterUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            // 👇 Use the robust stringify helper
+            body: stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "pm_getPaymasterStubData",
+              params: [userOp, entryPoint, {}],
+            }),
+          });
+
+          const data = await response.json();
+          if (data.error) throw new Error(data.error.message);
+
+          return data.result;
+        } catch (error) {
+          console.warn("Failed to get paymaster stub data:", error);
+          // ⚠️ If this fails, the UserOp usually fails with AA21
+          return { paymasterAndData: "0x" };
+        }
+      },
+
+      /**
+       * Get paymaster data for actual transaction
+       */
+      async getPaymasterData(userOp: any, entryPoint: Address): Promise<any> {
+        try {
+          const response = await fetch(paymasterUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "pm_getPaymasterData",
+              params: [userOp, entryPoint, {}],
+            }),
+          });
+
+          const data = await response.json();
+          if (data.error) throw new Error(data.error.message);
+
+          return data.result;
+        } catch (error) {
+          console.warn("Failed to get paymaster data:", error);
+          return null;
+        }
+      },
 
+      /**
+       * Sponsor user operation
+       */
+      async sponsorUserOperation(
+        userOp: any,
+        entryPoint: Address
+      ): Promise<any> {
+        try {
+          const response = await fetch(paymasterUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "pm_sponsorUserOperation",
+              params: [userOp, entryPoint, {}],
+            }),
+          });
+
+          const data = await response.json();
+          if (data.error) throw new Error(data.error.message);
+
+          return data.result;
+        } catch (error) {
+          console.warn("Failed to sponsor user operation:", error);
+          throw error;
+        }
+      },
+    };
+  }
   // ==============================================================================
   // Smart Account Management
   // ==============================================================================
@@ -65,30 +171,33 @@ export class DagAAClient {
   async connectSmartAccount(
     accountConfig: SmartAccountConfig
   ): Promise<Address> {
-    const owner = privateKeyToAccount(accountConfig.owner);
+    const { signer, accountAddress } = accountConfig;
 
-    const signingClient = createWalletClient({
-      account: owner,
-      chain: this.config.chain,
-      transport: http(this.config.rpcUrl),
-    });
+    const isReady = await signer.isReady();
+    if (!isReady) {
+      throw new Error("Signer is not ready. Ensure wallet is connected.");
+    }
+
+    const owner = await signer.getAccount();
+
+    const signingClient = await signer.getWalletClient();
 
-    if (accountConfig.accountAddress) {
+    if (accountAddress) {
       // Use existing account
       this.smartAccount = await toSimpleSmartAccount({
-        client: signingClient,
+        client: signingClient as unknown as Client,
         owner: owner,
         factoryAddress: this.config.factoryAddress,
         entryPoint: {
           address: this.config.entryPointAddress!,
           version: "0.6",
         },
-        address: accountConfig.accountAddress,
+        address: accountAddress,
       });
     } else {
       // Create new account
       this.smartAccount = await toSimpleSmartAccount({
-        client: signingClient,
+        client: signingClient as unknown as Client,
         owner: owner,
         factoryAddress: this.config.factoryAddress,
         entryPoint: {
@@ -107,12 +216,84 @@ export class DagAAClient {
       },
     });
 
-    // Create smart account client
-    this.smartAccountClient = createSmartAccountClient({
+    // Create smart account client with optional paymaster
+    const clientConfig: any = {
       bundlerTransport: http(this.config.bundlerUrl),
       chain: this.config.chain,
       account: this.smartAccount,
-    });
+    };
+
+    // Add paymaster if configured
+    if (this.paymasterClient) {
+      clientConfig.paymaster = {
+        getPaymasterData: async (userOperation: any) => {
+          console.log("🎫 Requesting paymaster sponsorship...");
+          console.log("UserOp sender:", userOperation.sender);
+
+          try {
+            const result = await this.paymasterClient!.sponsorUserOperation(
+              userOperation,
+              this.config.entryPointAddress!
+            );
+
+            console.log("Paymaster result:", result);
+
+            if (result && result.paymasterAndData) {
+              console.log("✅ Paymaster sponsorship approved!");
+              console.log("PaymasterAndData:", result.paymasterAndData);
+              return {
+                paymasterAndData: result.paymasterAndData,
+                ...(result.preVerificationGas && {
+                  preVerificationGas: BigInt(result.preVerificationGas),
+                }),
+                ...(result.verificationGasLimit && {
+                  verificationGasLimit: BigInt(result.verificationGasLimit),
+                }),
+                ...(result.callGasLimit && {
+                  callGasLimit: BigInt(result.callGasLimit),
+                }),
+              };
+            } else {
+              console.error("❌ No paymasterAndData in response:", result);
+              throw new Error("No paymaster data returned");
+            }
+          } catch (error) {
+            console.error("❌ Paymaster sponsorship failed:", error);
+            throw error;
+          }
+        },
+
+        getPaymasterStubData: async (userOperation: any) => {
+          console.log("📝 Getting paymaster stub data for gas estimation...");
+
+          try {
+            const result = await this.paymasterClient!.getPaymasterStubData(
+              userOperation,
+              this.config.entryPointAddress!
+            );
+
+            console.log("Stub data result:", result);
+
+            if (result && result.paymasterAndData) {
+              console.log("✅ Got paymaster stub data");
+              return {
+                paymasterAndData: result.paymasterAndData,
+              };
+            }
+          } catch (error) {
+            console.warn("⚠️ Failed to get paymaster stub data:", error);
+          }
+
+          // Return default stub if fails
+          console.log("⚠️ Using default stub data");
+          return {
+            paymasterAndData: "0x",
+          };
+        },
+      };
+    }
+
+    this.smartAccountClient = createSmartAccountClient(clientConfig);
 
     console.log(`✅ Connected to smart account: ${this.smartAccount.address}`);
     return this.smartAccount.address;
@@ -192,9 +373,9 @@ export class DagAAClient {
       value = 0n,
       maxFeePerGas,
       maxPriorityFeePerGas,
-      callGasLimit = 150000n,
-      verificationGasLimit = 300000n,
-      preVerificationGas = 100000n,
+      callGasLimit,
+      verificationGasLimit,
+      preVerificationGas,
     } = params;
 
     // Get gas prices if not provided
@@ -219,7 +400,7 @@ export class DagAAClient {
       `  Gas: ${gasPrices.maxFeePerGas} / ${gasPrices.maxPriorityFeePerGas}`
     );
 
-    const userOpHash = await this.smartAccountClient.sendTransaction({
+    const txOptions: any = {
       calls: [
         {
           to: target,
@@ -229,10 +410,16 @@ export class DagAAClient {
       ],
       maxFeePerGas: gasPrices.maxFeePerGas,
       maxPriorityFeePerGas: gasPrices.maxPriorityFeePerGas,
-      callGasLimit,
-      verificationGasLimit,
-      preVerificationGas,
-    });
+    };
+
+    // Add optional gas limits if provided
+    if (callGasLimit) txOptions.callGasLimit = callGasLimit;
+    if (verificationGasLimit)
+      txOptions.verificationGasLimit = verificationGasLimit;
+    if (preVerificationGas) txOptions.preVerificationGas = preVerificationGas;
+
+    // Send transaction - paymaster is automatically called if configured
+    const userOpHash = await this.smartAccountClient.sendTransaction(txOptions);
 
     console.log(`✅ UserOperation sent: ${userOpHash}`);
     return userOpHash;
@@ -326,8 +513,21 @@ export class DagAAClient {
     console.log(`Funding account with ${amount} wei...`);
 
     const hash = await client.sendTransaction({
+      account: signer, // ✅ Add this line
       to: this.smartAccount.address,
       value: amount,
+      kzg: {
+        blobToKzgCommitment: function (blob: ByteArray): ByteArray {
+          throw new Error("Function not implemented.");
+        },
+        computeBlobKzgProof: function (
+          blob: ByteArray,
+          commitment: ByteArray
+        ): ByteArray {
+          throw new Error("Function not implemented.");
+        },
+      },
+      chain: undefined,
     });
 
     console.log(`✅ Funded: ${hash}`);
@@ -363,14 +563,3 @@ export function createDagAAClient(config: DagAAConfig): DagAAClient {
 export function parseDAG(amount: string): bigint {
   return parseEther(amount);
 }
-
-// ==============================================================================
-// Export Types
-// ==============================================================================
-
-// export type {
-//   DagAAConfig,
-//   SmartAccountConfig,
-//   SendUserOperationParams,
-//   UserOperationReceipt,
-// };