@dag-kit/kit 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dag-kit/kit",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "author": "Abstract",
   "license": "MIT",
@@ -25,7 +25,7 @@
   "exports": {
     ".": {
       "types": "./dist/types/exports/index.d.ts",
-      "require": "./dist/esm/exports/index.js",
+      "default": "./dist/esm/exports/index.js",
       "import": "./dist/esm/exports/index.js"
     },
     "./experimental": {
@@ -58,7 +58,7 @@
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
   "scripts": {
     "prebuild": "tsx ./inject-version.ts",
-    "build": "yarn clean && yarn build:esm && yarn build:types",
+    "build": "pnpm clean && pnpm build:esm && pnpm build:types",
     "build:esm": "tsc --project tsconfig.build.json --outDir ./dist/esm",
     "build:types": "tsc --project tsconfig.build.json --declarationDir ./dist/types --emitDeclarationOnly --declaration --declarationMap",
     "clean": "rm -rf ./dist",

package/src/clients/actions/example2.ts

@@ -1,9 +1,11 @@
 import { awakening } from "../chains";
 import { createDagAAClient, parseDAG } from "./main";
+import { generatePrivateKey } from "viem/accounts";
 import { config as dotenvConfig } from "dotenv";
 dotenvConfig();
 
 const PRIVATE_KEY_2 = process.env.PRIVATE_KEY_1 as `0x${string}`;
+const ownerPrivy = generatePrivateKey();
 
 (async () => {
   console.log("Sending Simple Transaction");
@@ -13,17 +15,18 @@ const PRIVATE_KEY_2 = process.env.PRIVATE_KEY_1 as `0x${string}`;
     rpcUrl: "https://rpc.awakening.bdagscan.com",
     bundlerUrl: awakening.bundler_rpc,
     factoryAddress: "0x8FaB6DF00085eb05D5F2C1FA46a6E539587ae3f3",
+    paymasterUrl: "http://localhost:3001/rpc",
   });
 
   await client.connectSmartAccount({
     owner: "0x6b0f66a03b67d7b9eaa6c31123ffe5bf2ee58eb40ab86c8a14d6f1294838b0c8",
-    accountAddress: "0xDe10aaC59f659fA154C063153AB3f7Cca1fb23A5",
+    // accountAddress: "0xDe10aaC59f659fA154C063153AB3f7Cca1fb23A5",
   });
 
   // Send 0.01 DAG to an address
   const txHash = await client.sendUserOperation({
     target: "0x1749be926ef79a63a285b01263f7ddc350d435e6",
-    value: parseDAG("1"), // 0.01 DAG
+    value: parseDAG("0"), // 0.01 DAG
     maxFeePerGas: 50000000000n,
     maxPriorityFeePerGas: 50000000000n,
   });
@@ -33,25 +36,25 @@ const PRIVATE_KEY_2 = process.env.PRIVATE_KEY_1 as `0x${string}`;
   console.log("\n📦 Example : Batch Operations");
   console.log("═══════════════════════════\n");
 
-  await client.connectSmartAccount({
-    owner: PRIVATE_KEY_2,
-    accountAddress: "0x7fd5385efcB7B2898933288948a9496CDc0fA8ee",
-  });
-
-  // Send multiple operations
-  const hashes = await client.sendBatchUserOperations([
-    {
-      target: "0x1749be926ef79a63a285b01263f7ddc350d435e6",
-      value: parseDAG("0.5"),
-    },
-    {
-      target: "0x8371e519177f81b93287f750dcd06ce894c12cc5",
-      value: parseDAG("0.5"),
-    },
-  ]);
-
-  console.log(`Sent ${hashes.length} operations`);
-  hashes.forEach((hash, i) => {
-    console.log(`  ${i + 1}. ${hash}`);
-  });
+  // await client.connectSmartAccount({
+  //   owner: PRIVATE_KEY_2,
+  //   accountAddress: "0x7fd5385efcB7B2898933288948a9496CDc0fA8ee",
+  // });
+
+  // // Send multiple operations
+  // const hashes = await client.sendBatchUserOperations([
+  //   {
+  //     target: "0x1749be926ef79a63a285b01263f7ddc350d435e6",
+  //     value: parseDAG("0.5"),
+  //   },
+  //   {
+  //     target: "0x8371e519177f81b93287f750dcd06ce894c12cc5",
+  //     value: parseDAG("0.5"),
+  //   },
+  // ]);
+
+  // console.log(`Sent ${hashes.length} operations`);
+  // hashes.forEach((hash, i) => {
+  //   console.log(`  ${i + 1}. ${hash}`);
+  // });
 })();

package/src/clients/actions/main.ts

@@ -37,6 +37,7 @@ export class DagAAClient {
   private walletClient: ReturnType<typeof createWalletClient>;
   private bundlerClient: ReturnType<typeof createPimlicoClient> | null = null;
   private smartAccount: any | null = null;
+  private paymasterClient: any | null = null;
   private smartAccountClient: ReturnType<
     typeof createSmartAccountClient
   > | null = null;
@@ -56,8 +57,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
   // ==============================================================================
@@ -107,12 +212,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 +369,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 +396,7 @@ export class DagAAClient {
       `  Gas: ${gasPrices.maxFeePerGas} / ${gasPrices.maxPriorityFeePerGas}`
     );
 
-    const userOpHash = await this.smartAccountClient.sendTransaction({
+    const txOptions: any = {
       calls: [
         {
           to: target,
@@ -229,10 +406,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;
@@ -363,14 +546,3 @@ export function createDagAAClient(config: DagAAConfig): DagAAClient {
 export function parseDAG(amount: string): bigint {
   return parseEther(amount);
 }
-
-// ==============================================================================
-// Export Types
-// ==============================================================================
-
-// export type {
-//   DagAAConfig,
-//   SmartAccountConfig,
-//   SendUserOperationParams,
-//   UserOperationReceipt,
-// };

package/src/clients/actions/test.ts

@@ -0,0 +1,210 @@
+import "dotenv/config";
+import { toSimpleSmartAccount } from "permissionless/accounts";
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseEther,
+  encodeFunctionData,
+  defineChain,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import { entryPoint06Address } from "viem/account-abstraction";
+import { createSmartAccountClient } from "permissionless";
+import { abi } from "./contract";
+
+// Configuration
+const adminKey =
+  "0x5810098e367422376897bb2645c5ada5850a99aeec0505a58d38853ebd7f9f31";
+const FACTORY_ADDRESS = "0x8FaB6DF00085eb05D5F2C1FA46a6E539587ae3f3"; // Your factory
+const TARGET_ADDRESS = "0x7fd5385efcB7B2898933288948a9496CDc0fA8ee"; // Your desired address
+
+// BlockDAG Awakening Testnet
+const awakening = defineChain({
+  id: 1043,
+  name: "Awakening Testnet",
+  nativeCurrency: { decimals: 18, name: "Dag", symbol: "DAG" },
+  rpcUrls: { default: { http: ["https://relay.awakening.bdagscan.com"] } },
+  blockExplorers: {
+    default: { name: "Explorer", url: "https://awakening.bdagscan.com/" },
+  },
+});
+
+const localBundler = "http://0.0.0.0:3000/";
+
+console.log("\n🔍 Using Your Existing Address");
+console.log("=================================\n");
+
+const publicClient = createPublicClient({
+  chain: awakening,
+  transport: http(awakening.rpcUrls.default.http[0]),
+});
+
+const walletClient = createWalletClient({
+  account: privateKeyToAccount(adminKey),
+  chain: awakening,
+  transport: http(awakening.rpcUrls.default.http[0]),
+});
+
+console.log(`Target Address: ${TARGET_ADDRESS}`);
+console.log(`Owner: ${privateKeyToAccount(adminKey).address}`);
+console.log(`Factory: ${FACTORY_ADDRESS}\n`);
+
+// Step 1: Create account using the specific address
+// Since the account is already deployed, we just need to reference it
+const account = await toSimpleSmartAccount({
+  client: publicClient,
+  owner: privateKeyToAccount(adminKey),
+  factoryAddress: FACTORY_ADDRESS,
+  entryPoint: {
+    address: entryPoint06Address,
+    version: "0.6",
+  },
+  address: TARGET_ADDRESS, // Use the existing address directly
+});
+
+console.log("=== Smart Account Information ===");
+console.log(`Address: ${account.address}`);
+console.log(
+  `Explorer: https://awakening.bdagscan.com/address/${account.address}`
+);
+console.log("✅ Using your existing account\n");
+
+// Check if deployed
+const code = await publicClient.getCode({
+  address: account.address,
+});
+
+const isDeployed = code && code !== "0x";
+console.log(
+  `Deployment Status: ${isDeployed ? "✅ Deployed" : "⚠️ Not deployed"}`
+);
+
+// Check balance
+const balance = await publicClient.getBalance({
+  address: account.address,
+});
+
+const balanceInDAG = Number(balance) / 1e18;
+console.log(`Balance: ${balanceInDAG} DAG`);
+
+if (!isDeployed) {
+  console.log("\n⚠️ Account not deployed yet.");
+  console.log("The account should already be deployed based on the explorer.");
+  console.log("If you need to deploy it, do so manually first.\n");
+}
+
+// Step 3: Test bundler connection
+console.log("=== Testing Bundler ===");
+try {
+  const dagClient = createPimlicoClient({
+    transport: http(localBundler),
+    entryPoint: {
+      address: entryPoint06Address,
+      version: "0.6",
+    },
+  });
+
+  const gasPrice = await dagClient.getUserOperationGasPrice();
+  console.log("✅ Bundler responding");
+  console.log(`Gas Price: ${gasPrice.fast.maxFeePerGas} wei\n`);
+} catch (error: any) {
+  console.error("❌ Bundler not responding:", error.message);
+  console.log("\n💡 Start Alto bundler:");
+  console.log(`./alto \\
+  --entrypoints "${entryPoint06Address}" \\
+  --executor-private-keys "${adminKey}" \\
+  --utility-private-key "${adminKey}" \\
+  --rpc-url "https://relay.awakening.bdagscan.com" \\
+  --port 3000 \\
+  --safe-mode false \\
+  --dangerous-skip-user-operation-validation true`);
+  process.exit(1);
+}
+
+// Step 4: Send test UserOperation
+console.log("=== Sending Test UserOperation ===");
+
+const smartAccountClient = createSmartAccountClient({
+  bundlerTransport: http(localBundler),
+  chain: awakening,
+  account,
+});
+
+const cd = encodeFunctionData({
+  abi,
+  functionName: "decrement",
+  args: [],
+});
+
+try {
+  // Simple test: send 0 value to self
+  const txHash = await smartAccountClient.sendTransaction({
+    to: "0x692e69cA1Fe89eF72ca94B0E3a32A92835501a08",
+    value: 0n,
+    data: cd,
+    maxFeePerGas: 50000000000n, // 50 gwei
+    maxPriorityFeePerGas: 50000000000n, // 50 gwei
+    callGasLimit: 150000n,
+    verificationGasLimit: 500000n,
+    preVerificationGas: 100000n,
+  });
+
+  console.log(`\n✅ Success!`);
+  console.log(`UserOperation Hash: ${txHash}`);
+  console.log(`Explorer: https://awakening.bdagscan.com/tx/${txHash}`);
+
+  console.log("\n⏳ Waiting for confirmation...");
+  await new Promise((resolve) => setTimeout(resolve, 5000));
+
+  const newBalance = await publicClient.getBalance({
+    address: account.address,
+  });
+  const newBalanceInDAG = Number(newBalance) / 1e18;
+  console.log(`\nFinal Balance: ${newBalanceInDAG} DAG`);
+  console.log(`Gas Cost: ${balanceInDAG - newBalanceInDAG} DAG`);
+
+  console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("🎉 Success! Your account is ready for reuse.");
+  console.log(`   Address: ${TARGET_ADDRESS}`);
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+
+  const result = await publicClient.readContract({
+    address: "0x692e69cA1Fe89eF72ca94B0E3a32A92835501a08",
+    abi: abi,
+    functionName: "getNum",
+  });
+
+  console.log("Result is given as", result);
+} catch (error: any) {
+  console.error("\n❌ Transaction failed:");
+  console.error(error.message);
+
+  if (error.message?.includes("Missing or invalid parameters")) {
+    console.log("\n⚠️ This is the known Awakening RPC issue.");
+    console.log("The RPC cannot properly handle eth_call for UserOperations.");
+    console.log(
+      "\nYour setup is correct - the issue is with Awakening's RPC implementation."
+    );
+  }
+
+  if (error.details) {
+    console.log("\nDetails:", error.details);
+  }
+}
+
+// Instructions for reuse
+console.log("\n💾 To reuse this address in future scripts:");
+console.log(`
+const account = await toSimpleSmartAccount({
+  client: publicClient,
+  owner: privateKeyToAccount(adminKey),
+  factoryAddress: "${FACTORY_ADDRESS}",
+  entryPoint: {
+    address: entryPoint06Address,
+    version: "0.6",
+  },
+  address: "${TARGET_ADDRESS}", // Your existing account
+});
+`);

package/src/clients/actions/testPaymasterService.ts

@@ -0,0 +1,94 @@
+// Test if paymaster service is working
+
+async function testPaymasterService() {
+  const PAYMASTER_URL = "http://localhost:3001/rpc";
+
+  console.log("Testing paymaster service...");
+
+  // Test 1: Health check
+  try {
+    const healthResponse = await fetch("http://localhost:3001/health");
+    const health = await healthResponse.json();
+    console.log("✅ Health check passed:", health);
+  } catch (error) {
+    console.error("❌ Health check failed:", error);
+    console.error("Is the paymaster service running? Run: pnpm start");
+    process.exit(1);
+  }
+
+  // Test 2: Get paymaster info
+  try {
+    const infoResponse = await fetch("http://localhost:3001/info");
+    const info = await infoResponse.json();
+    console.log("✅ Paymaster info:", info);
+  } catch (error) {
+    console.error("❌ Failed to get paymaster info:", error);
+  }
+
+  // Test 3: Test pm_getPaymasterStubData
+  const mockUserOp = {
+    sender: "0xCa28afE1e9Fb8B9AF996c97F3dc291bE54EAEe4E",
+    nonce: "0x0",
+    initCode: "0x",
+    callData: "0x",
+    callGasLimit: "0x30d40",
+    verificationGasLimit: "0x30d40",
+    preVerificationGas: "0x30d40",
+    maxFeePerGas: "0xba43b7400",
+    maxPriorityFeePerGas: "0xba43b7400",
+    paymasterAndData: "0x",
+    signature: "0x",
+  };
+
+  try {
+    const response = await fetch(PAYMASTER_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "pm_getPaymasterStubData",
+        params: [mockUserOp, "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789", {}],
+      }),
+    });
+
+    const data = await response.json();
+
+    if (data.error) {
+      console.error("❌ pm_getPaymasterStubData failed:", data.error);
+    } else {
+      console.log("✅ pm_getPaymasterStubData success:", data.result);
+    }
+  } catch (error) {
+    console.error("❌ pm_getPaymasterStubData request failed:", error);
+  }
+
+  // Test 4: Test pm_sponsorUserOperation
+  try {
+    const response = await fetch(PAYMASTER_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "pm_sponsorUserOperation",
+        params: [mockUserOp, "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789", {}],
+      }),
+    });
+
+    const data = await response.json();
+
+    if (data.error) {
+      console.error("❌ pm_sponsorUserOperation failed:", data.error);
+    } else {
+      console.log("✅ pm_sponsorUserOperation success:");
+      console.log("   paymasterAndData:", data.result.paymasterAndData);
+    }
+  } catch (error) {
+    console.error("❌ pm_sponsorUserOperation request failed:", error);
+  }
+
+  console.log("\n✅ Paymaster tests complete!");
+}
+
+testPaymasterService().catch(console.error);

package/src/clients/chains.ts

@@ -1,5 +1,5 @@
 import { defineChain } from "viem";
-
+import { arbitrumSepolia } from "viem/chains";
 const awakening_ = defineChain({
   id: 1043,
   name: "Awakening Testnet",
@@ -14,3 +14,8 @@ export const awakening = {
   bundler_rpc: "http://0.0.0.0:3000/",
   chain_config: awakening_,
 };
+
+export const arbitrumSep = {
+  bundler_rpc: "http://0.0.0.0:3001/",
+  chain_config: arbitrumSepolia,
+};