gokite-aa-sdk 1.0.8 → 1.0.10

package/dist/config.js

@@ -6,7 +6,7 @@ exports.NETWORKS = {
         chainId: 2368,
         entryPoint: '0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108',
         accountFactory: '0xAba80c4c8748c114Ba8b61cda3b0112333C3b96E',
-        accountImplementation: '0xc033eC55a6c6fa7aDe6EcE95835113fC64Fc2e3F',
+        accountImplementation: '0x376c32FcE28aa8496465a9E5C8a03ED8B1a7fB4D',
         paymaster: '0x9Adcbf85D5c724611a490Ba9eDc4d38d6F39e92d',
         supportedTokens: [
             { address: '0x0000000000000000000000000000000000000000', symbol: 'KITE', decimals: 18 },

package/dist/example-token-paymaster.js

@@ -6,122 +6,246 @@ require("dotenv/config");
 const NETWORK = "kite_testnet";
 const RPC_URL = "https://rpc-testnet.gokite.ai";
 const BUNDLER_URL = "https://bundler-service.staging.gokite.ai/rpc/";
-// const BUNDLER_URL = "http://localhost:14337/rpc/";
 const SETTLEMENT_TOKEN = "0x0fF5393387ad2f9f691FD6Fd28e07E3969e27e63";
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 const sdk = new gokite_aa_sdk_1.GokiteAASDK(NETWORK, RPC_URL, BUNDLER_URL);
-const sessionInterface = new ethers_1.ethers.Interface([
-    "function createSession(bytes32 sessionId, address settlementToken, tuple(uint256 timeWindow, uint160 budget, uint96 initialWindowStartTime, bytes32[] targetProviders)[] rules)",
-    "function setSpendingRules(bytes32 sessionId, tuple(uint256 timeWindow, uint160 budget, uint96 initialWindowStartTime, bytes32[] targetProviders)[] rules)",
-]);
-const erc20Interface = new ethers_1.ethers.Interface([
-    "function transfer(address to, uint256 amount)",
+// GokiteAccount interface (includes SessionManager functions)
+const gokiteAccountInterface = new ethers_1.ethers.Interface([
+    // Token whitelist
+    "function addSupportedToken(address token)",
+    // Master budget
+    "function setMasterBudgetRules(uint256[] timeWindows, uint160[] budgets)",
+    // Session management
+    "function createSession(bytes32 sessionId, address agent, tuple(uint256 timeWindow, uint160 budget, uint96 initialWindowStartTime, bytes32[] targetProviders)[] rules)",
+    // Transfer execution
+    "function executeTransferWithAuthorization(bytes32 sessionId, tuple(address from, address to, address token, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce) auth, bytes signature)",
+    // Batch execution
+    "function executeBatch(address[] dest, uint256[] value, bytes[] func)",
+    // ============ View Functions (for frontend queries) ============
+    // Token whitelist queries
+    "function isTokenSupported(address token) view returns (bool)",
+    "function getTokenDecimals(address token) view returns (uint8)",
+    "function getAvailableBalance(address token) view returns (uint256)",
+    // Session queries
+    "function sessionExists(bytes32 sessionId) view returns (bool)",
+    "function getSessionAgent(bytes32 sessionId) view returns (address)",
+    "function getSpendingRules(bytes32 sessionId) view returns (tuple(tuple(uint256 timeWindow, uint160 budget, uint96 initialWindowStartTime, bytes32[] targetProviders) rule, tuple(uint128 amountUsed, uint128 currentTimeWindowStartTime) usage)[])",
+    "function getUsage(bytes32 sessionId, uint256 index) view returns (uint256)",
+    "function checkSpendingRules(bytes32 sessionId, uint256 normalizedAmount, bytes32 serviceProvider) view returns (bool)",
+    // Master budget queries
+    "function getMasterBudgetRules() view returns (tuple(tuple(uint256 timeWindow, uint160 budget, uint96 initialWindowStartTime, bytes32[] targetProviders) rule, tuple(uint128 amountUsed, uint128 currentTimeWindowStartTime) usage)[])",
+    "function getMasterBudgetRuleCount() view returns (uint256)",
+    // Nonce queries
+    "function isNonceUsed(bytes32 nonce) view returns (bool)",
 ]);
 /**
- * Frontend note:
- * 1. Creates an AA session and seeds it with example spending rules (daily, weekly, per-transaction caps).
- * 2. Updates that session to demonstrate how rule changes propagate on-chain.
- * 3. Executes an ERC20 transfer
+ * E2E Demo for AA Session, Budget, and Pay flow:
+ * 1. Setup AA wallet: addSupportedToken + setMasterBudgetRules
+ * 2. Create session with agent and spending rules
+ * 3. Agent signs EIP-712 transfer authorization
+ * 4. Execute transfer with authorization
  */
-const PRIVATE_KEY = process.env.PRIVATE_KEY;
+// Owner: controls AA wallet, signs UserOps
+const OWNER_PRIVATE_KEY = process.env.PRIVATE_KEY;
+// Agent: signs transfer authorizations (can be same as owner for demo)
+const AGENT_PRIVATE_KEY = process.env.AGENT_PRIVATE_KEY ?? OWNER_PRIVATE_KEY;
 const PAYMENT_TOKEN = process.env.PAYMENT_TOKEN ?? SETTLEMENT_TOKEN;
-if (!PRIVATE_KEY)
+if (!OWNER_PRIVATE_KEY)
     throw new Error("Missing PRIVATE_KEY env variable");
-const signer = new ethers_1.ethers.Wallet(PRIVATE_KEY);
-const sessionId = (0, ethers_1.randomBytes)(32);
-const secondsPerDay = 86400;
+const ownerSigner = new ethers_1.ethers.Wallet(OWNER_PRIVATE_KEY);
+const agentSigner = new ethers_1.ethers.Wallet(AGENT_PRIVATE_KEY);
+const sessionId = ethers_1.ethers.hexlify((0, ethers_1.randomBytes)(32));
+const SECONDS_PER_DAY = 86400;
 function currentDayStart() {
     const now = Math.floor(Date.now() / 1000);
-    return BigInt(Math.floor(now / secondsPerDay) * secondsPerDay);
-}
-function currentWeekStart() {
-    const now = new Date();
-    const dayStart = Number(currentDayStart());
-    const weekday = now.getUTCDay();
-    const daysFromMonday = (weekday + 6) % 7;
-    return BigInt(dayStart - daysFromMonday * secondsPerDay);
+    return BigInt(Math.floor(now / SECONDS_PER_DAY) * SECONDS_PER_DAY);
 }
 async function signUserOp(hash) {
-    return signer.signMessage(ethers_1.ethers.getBytes(hash));
+    return ownerSigner.signMessage(ethers_1.ethers.getBytes(hash));
 }
 async function sendWithTokenPayment(target, callData) {
-    const request = {
-        target,
-        value: 0n,
-        callData,
-    };
-    const estimate = await sdk.estimateUserOperation(signer.address, request);
+    const request = { target, value: 0n, callData };
+    const estimate = await sdk.estimateUserOperation(ownerSigner.address, request);
     const tokenAddress = estimate.sponsorshipAvailable ? ZERO_ADDRESS : PAYMENT_TOKEN;
-    const response = await sdk.sendUserOperationWithPayment(signer.address, request, estimate.userOp, tokenAddress, signUserOp);
+    const response = await sdk.sendUserOperationWithPayment(ownerSigner.address, request, estimate.userOp, tokenAddress, signUserOp);
     if (response.status.status !== "success") {
         throw new Error(response.status.reason ?? "User operation failed");
     }
     return response.status.transactionHash ?? "";
 }
-function initialRules() {
+// EIP-712 domain for GokiteAccount
+function getEIP712Domain(aaWallet, chainId) {
+    return {
+        name: "GokiteAccount",
+        version: "1",
+        chainId: chainId,
+        verifyingContract: aaWallet,
+    };
+}
+// EIP-712 types for TransferWithAuthorization
+const TRANSFER_AUTH_TYPES = {
+    TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "token", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" },
+    ],
+};
+// Sign transfer authorization using EIP-712
+async function signTransferAuthorization(aaWallet, chainId, auth) {
+    const domain = getEIP712Domain(aaWallet, chainId);
+    return agentSigner.signTypedData(domain, TRANSFER_AUTH_TYPES, auth);
+}
+// Session spending rules
+function sessionRules() {
     return [
         {
-            timeWindow: 86400n,
+            timeWindow: BigInt(SECONDS_PER_DAY),
             budget: ethers_1.ethers.parseUnits("100", 18),
             initialWindowStartTime: currentDayStart(),
             targetProviders: [],
         },
-        {
-            timeWindow: 604800n,
-            budget: ethers_1.ethers.parseUnits("1000", 18),
-            initialWindowStartTime: currentWeekStart(),
-            targetProviders: [],
-        },
         {
             timeWindow: 0n,
             budget: ethers_1.ethers.parseUnits("10", 18),
             initialWindowStartTime: 0n,
-            targetProviders: [
-                ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes("provider1")),
-            ],
-        },
-    ];
-}
-function updatedRules() {
-    return [
-        {
-            timeWindow: 86400n,
-            budget: ethers_1.ethers.parseUnits("200", 18),
-            initialWindowStartTime: currentDayStart(),
-            targetProviders: [],
-        },
-        {
-            timeWindow: 0n,
-            budget: ethers_1.ethers.parseUnits("5", 18),
-            initialWindowStartTime: 0n,
             targetProviders: [],
         },
     ];
 }
+// ============ Frontend View Functions Examples ============
+async function queryWalletStatus(aaWallet, provider) {
+    const contract = new ethers_1.ethers.Contract(aaWallet, gokiteAccountInterface, provider);
+    console.log("\n[Query] AA Wallet Status");
+    console.log("=".repeat(50));
+    // 1. Check if token is supported
+    const isSupported = await contract.isTokenSupported(SETTLEMENT_TOKEN);
+    console.log(`  Token ${SETTLEMENT_TOKEN} supported: ${isSupported}`);
+    // 2. Get token balance in AA wallet
+    const balance = await contract.getAvailableBalance(SETTLEMENT_TOKEN);
+    console.log(`  Token balance: ${ethers_1.ethers.formatUnits(balance, 18)}`);
+    // 3. Get master budget rules
+    const masterRules = await contract.getMasterBudgetRules();
+    console.log(`  Master budget rules count: ${masterRules.length}`);
+    for (let i = 0; i < masterRules.length; i++) {
+        const rule = masterRules[i];
+        const timeWindow = rule.rule.timeWindow;
+        const budget = ethers_1.ethers.formatUnits(rule.rule.budget, 18);
+        const used = ethers_1.ethers.formatUnits(rule.usage.amountUsed, 18);
+        const windowType = timeWindow === 0n ? "per-tx" : `${Number(timeWindow) / 86400} day(s)`;
+        console.log(`    Rule ${i}: ${windowType}, budget: ${budget}, used: ${used}`);
+    }
+    return { isSupported, balance };
+}
+async function querySessionStatus(aaWallet, sessionId, provider) {
+    const contract = new ethers_1.ethers.Contract(aaWallet, gokiteAccountInterface, provider);
+    console.log("\n[Query] Session Status");
+    console.log("=".repeat(50));
+    // 1. Check if session exists
+    const exists = await contract.sessionExists(sessionId);
+    console.log(`  Session ${sessionId.slice(0, 18)}... exists: ${exists}`);
+    if (!exists)
+        return { exists };
+    // 2. Get session agent
+    const agent = await contract.getSessionAgent(sessionId);
+    console.log(`  Session agent: ${agent}`);
+    // 3. Get spending rules
+    const spendingRules = await contract.getSpendingRules(sessionId);
+    console.log(`  Spending rules count: ${spendingRules.length}`);
+    for (let i = 0; i < spendingRules.length; i++) {
+        const rule = spendingRules[i];
+        const timeWindow = rule.rule.timeWindow;
+        const budget = ethers_1.ethers.formatUnits(rule.rule.budget, 18);
+        const used = ethers_1.ethers.formatUnits(rule.usage.amountUsed, 18);
+        const windowType = timeWindow === 0n ? "per-tx" : `${Number(timeWindow) / 86400} day(s)`;
+        console.log(`    Rule ${i}: ${windowType}, budget: ${budget}, used: ${used}`);
+    }
+    // 4. Check if a specific amount would pass spending rules
+    const testAmount = ethers_1.ethers.parseUnits("5", 18);
+    const wouldPass = await contract.checkSpendingRules(sessionId, testAmount, ethers_1.ethers.ZeroHash);
+    console.log(`  Would ${ethers_1.ethers.formatUnits(testAmount, 18)} pass spending rules: ${wouldPass}`);
+    return { exists, agent, spendingRules };
+}
+async function checkNonceStatus(aaWallet, nonce, provider) {
+    const contract = new ethers_1.ethers.Contract(aaWallet, gokiteAccountInterface, provider);
+    const isUsed = await contract.isNonceUsed(nonce);
+    console.log(`  Nonce ${nonce.slice(0, 18)}... used: ${isUsed}`);
+    return isUsed;
+}
 async function main() {
-    const aaWallet = sdk.getAccountAddress(signer.address);
-    const createSessionData = sessionInterface.encodeFunctionData("createSession", [
-        sessionId,
+    const aaWallet = sdk.getAccountAddress(ownerSigner.address);
+    const provider = new ethers_1.ethers.JsonRpcProvider(RPC_URL);
+    const chainId = (await provider.getNetwork()).chainId;
+    // ============ Frontend Query Examples ============
+    await queryWalletStatus(aaWallet, provider);
+    // ============ Step 1: Setup AA Wallet (batch: addSupportedToken + setMasterBudgetRules) ============
+    console.log("\n[Step 1] Setting up AA wallet...");
+    const addTokenData = gokiteAccountInterface.encodeFunctionData("addSupportedToken", [
         SETTLEMENT_TOKEN,
-        initialRules(),
     ]);
-    const createTx = await sendWithTokenPayment(aaWallet, createSessionData);
-    console.log(`createSession tx: ${createTx}`);
-    await new Promise(resolve => setTimeout(resolve, 10000));
-    const updateRulesData = sessionInterface.encodeFunctionData("setSpendingRules", [
-        sessionId,
-        updatedRules(),
+    const masterBudgetData = gokiteAccountInterface.encodeFunctionData("setMasterBudgetRules", [
+        [BigInt(SECONDS_PER_DAY), 0n],
+        [ethers_1.ethers.parseUnits("1000", 18), ethers_1.ethers.parseUnits("100", 18)], // 1000 USD/day, 100 USD/tx
     ]);
-    const updateTx = await sendWithTokenPayment(aaWallet, updateRulesData);
-    console.log(`setSpendingRules tx: ${updateTx}`);
-    await new Promise(resolve => setTimeout(resolve, 10000));
-    const RECIPIENT = signer.address;
-    const transferData = erc20Interface.encodeFunctionData("transfer", [
-        RECIPIENT,
-        ethers_1.ethers.parseUnits("0", 18),
+    const setupBatchData = gokiteAccountInterface.encodeFunctionData("executeBatch", [
+        [aaWallet, aaWallet],
+        [],
+        [addTokenData, masterBudgetData],
     ]);
-    const transferTx = await sendWithTokenPayment(SETTLEMENT_TOKEN, transferData);
-    console.log(`transfer tx: ${transferTx}`);
+    // const setupTx = await sendWithTokenPayment(aaWallet, setupBatchData);
+    // console.log(`  Setup (addSupportedToken + setMasterBudgetRules) tx: ${setupTx}`);
+    // await new Promise((r) => setTimeout(r, 5000));
+    // ============ Step 2: Create Session ============
+    console.log("\n[Step 2] Creating session...");
+    const createSessionData = gokiteAccountInterface.encodeFunctionData("createSession", [
+        sessionId,
+        agentSigner.address,
+        sessionRules(),
+    ]);
+    const createSessionTx = await sendWithTokenPayment(aaWallet, createSessionData);
+    console.log(`  Session ID: ${sessionId}`);
+    console.log(`  createSession tx: ${createSessionTx}`);
+    await new Promise((r) => setTimeout(r, 5000));
+    // Query session status after creation
+    await querySessionStatus(aaWallet, sessionId, provider);
+    // ============ Step 3: Sign Transfer Authorization ============
+    console.log("\n[Step 3] Agent signing transfer authorization...");
+    const recipient = ownerSigner.address; // send to self for demo
+    const transferAmount = ethers_1.ethers.parseUnits("1", 18); // 1 token
+    const nonce = ethers_1.ethers.hexlify((0, ethers_1.randomBytes)(32));
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const auth = {
+        from: aaWallet,
+        to: recipient,
+        token: SETTLEMENT_TOKEN,
+        value: transferAmount,
+        validAfter: now - 60n,
+        validBefore: now + 3600n,
+        nonce: nonce,
+    };
+    const signature = await signTransferAuthorization(aaWallet, chainId, auth);
+    console.log(`  Authorization nonce: ${nonce}`);
+    console.log(`  Signature: ${signature.slice(0, 42)}...`);
+    // ============ Step 4: Execute Transfer ============
+    console.log("\n[Step 4] Executing transfer with authorization...");
+    const executeTransferData = gokiteAccountInterface.encodeFunctionData("executeTransferWithAuthorization", [sessionId, auth, signature]);
+    const executeTx = await sendWithTokenPayment(aaWallet, executeTransferData);
+    console.log(`  executeTransferWithAuthorization tx: ${executeTx}`);
+    await new Promise((r) => setTimeout(r, 5000));
+    // ============ Post-Transfer Queries ============
+    console.log("\n[Post-Transfer] Checking status...");
+    // Check nonce is now used (replay protection)
+    await checkNonceStatus(aaWallet, nonce, provider);
+    // Query updated session status (usage should be updated)
+    await querySessionStatus(aaWallet, sessionId, provider);
+    // Query updated wallet status
+    await queryWalletStatus(aaWallet, provider);
+    console.log("\n" + "=".repeat(60));
+    console.log("E2E Demo completed successfully!");
+    console.log("=".repeat(60));
 }
 main().catch((error) => {
     console.error(error);

package/dist/gokite-aa-sdk.js

@@ -78,8 +78,10 @@ class BundlerProvider {
                 callGasLimit: BigInt(result.result.callGasLimit),
                 verificationGasLimit: BigInt(result.result.verificationGasLimit),
                 preVerificationGas: BigInt(result.result.preVerificationGas),
-                maxFeePerGas: BigInt(result.result.maxFeePerGas || 1000000000n),
-                maxPriorityFeePerGas: BigInt(result.result.maxPriorityFeePerGas || 1000000000n), // 1 gwei
+                // maxFeePerGas: BigInt(result.result.maxFeePerGas || 1000000000n), // 1 gwei
+                // maxPriorityFeePerGas: BigInt(result.result.maxPriorityFeePerGas || 1000000000n), // 1 gwei
+                maxFeePerGas: BigInt(1000000000n),
+                maxPriorityFeePerGas: BigInt(1000000000n),
             };
         }
         catch (error) {
@@ -314,6 +316,7 @@ class GokiteAASDK {
         // Update gas fields in packed format (verificationGasLimit first, callGasLimit second)
         userOp.accountGasLimits = (0, utils_1.packAccountGasLimits)(gasEstimate.verificationGasLimit, gasEstimate.callGasLimit);
         userOp.preVerificationGas = gasEstimate.preVerificationGas;
+        userOp.gasFees = (0, utils_1.packAccountGasLimits)(gasEstimate.maxPriorityFeePerGas, gasEstimate.maxFeePerGas);
         const userOpHash = await this.getUserOpHash(userOp);
         // Sign user operation
         const signature = await signFn(userOpHash);
@@ -426,8 +429,10 @@ class GokiteAASDK {
             gasEstimate.callGasLimit = gasEstimate.callGasLimit + 5000000n;
             gasEstimate.verificationGasLimit = gasEstimate.verificationGasLimit + 1000000n;
             gasEstimate.preVerificationGas = gasEstimate.preVerificationGas + 1000000n;
-            gasEstimate.maxFeePerGas = BigInt(100000000);
-            gasEstimate.maxPriorityFeePerGas = BigInt(1);
+            // gasEstimate.maxFeePerGas = BigInt(gasEstimate.maxFeePerGas || 1000000000n); // 1 gwei
+            // gasEstimate.maxPriorityFeePerGas = BigInt(gasEstimate.maxPriorityFeePerGas || 1000000000n); // 1 gwei
+            gasEstimate.maxFeePerGas = BigInt(1000000000n);
+            gasEstimate.maxPriorityFeePerGas = BigInt(1000000000n);
             userOp.gasFees = (0, utils_1.packAccountGasLimits)(gasEstimate.maxPriorityFeePerGas, gasEstimate.maxFeePerGas);
             // Pack gas limits and fees (note: verificationGasLimit first, callGasLimit second)
             userOp.accountGasLimits = (0, utils_1.packAccountGasLimits)(gasEstimate.verificationGasLimit, gasEstimate.callGasLimit);

package/dist/utils.js

@@ -130,7 +130,7 @@ function serializeUserOperation(userOp) {
 exports.serializeUserOperation = serializeUserOperation;
 // default salt is 0
 function generateSalt() {
-    return BigInt(5);
+    return BigInt(0);
 }
 exports.generateSalt = generateSalt;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gokite-aa-sdk",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Simple and clean Account Abstraction SDK for Gokite",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",