gokite-aa-sdk 1.0.9 → 1.0.11

package/dist/buy-content.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Buy Content Script
+ *
+ * This script demonstrates the complete x402 payment flow:
+ * 1. Request protected content (receive 402 + PaymentRequirements)
+ * 2. Sign EIP-712 transfer authorization
+ * 3. Send payment via X-Payment header
+ * 4. Receive content (service verifies & settles via facilitator)
+ *
+ * Usage:
+ *   npm run buy
+ *
+ * Environment variables (from .env.local):
+ *   AA_WALLET           - AA wallet address
+ *   SESSION_ID          - Session ID for this agent
+ *   AGENT_PRIVATE_KEY   - Agent private key (signs authorizations)
+ *   SERVICE_URL         - Protected service URL
+ *   FACILITATOR_URL     - x402 facilitator URL (for health check)
+ */
+import "dotenv/config";

package/dist/buy-content.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Buy Content Script
+ *
+ * This script demonstrates the complete x402 payment flow:
+ * 1. Request protected content (receive 402 + PaymentRequirements)
+ * 2. Sign EIP-712 transfer authorization
+ * 3. Send payment via X-Payment header
+ * 4. Receive content (service verifies & settles via facilitator)
+ *
+ * Usage:
+ *   npm run buy
+ *
+ * Environment variables (from .env.local):
+ *   AA_WALLET           - AA wallet address
+ *   SESSION_ID          - Session ID for this agent
+ *   AGENT_PRIVATE_KEY   - Agent private key (signs authorizations)
+ *   SERVICE_URL         - Protected service URL
+ *   FACILITATOR_URL     - x402 facilitator URL (for health check)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+require("dotenv/config");
+// =============================================================================
+// Configuration
+// =============================================================================
+const CHAIN_ID = 2368n;
+const RPC_URL = "https://rpc-testnet.gokite.ai";
+// From environment
+const AA_WALLET = process.env.AA_WALLET;
+const SESSION_ID = process.env.SESSION_ID;
+const AGENT_PRIVATE_KEY = process.env.AGENT_PRIVATE_KEY;
+const SERVICE_URL = process.env.SERVICE_URL || "http://localhost:8099";
+const FACILITATOR_URL = process.env.FACILITATOR_URL || "http://localhost:8080";
+// Validate environment
+if (!AA_WALLET || !SESSION_ID || !AGENT_PRIVATE_KEY) {
+    console.error("❌ Missing environment variables. Please run setup first:");
+    console.error("   npm run setup");
+    console.error("\n   Required: AA_WALLET, SESSION_ID, AGENT_PRIVATE_KEY");
+    process.exit(1);
+}
+const agentSigner = new ethers_1.ethers.Wallet(AGENT_PRIVATE_KEY);
+// =============================================================================
+// EIP-712 Signing
+// =============================================================================
+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" },
+    ],
+};
+function getEIP712Domain(aaWallet, chainId) {
+    return {
+        name: "GokiteAccount",
+        version: "1",
+        chainId: chainId,
+        verifyingContract: aaWallet,
+    };
+}
+async function signTransferAuthorization(aaWallet, chainId, auth) {
+    const domain = getEIP712Domain(aaWallet, chainId);
+    return agentSigner.signTypedData(domain, TRANSFER_AUTH_TYPES, auth);
+}
+// =============================================================================
+// Payment Flow Functions
+// =============================================================================
+/**
+ * Step 1: Request content without payment
+ * Expected: 402 Payment Required with PaymentRequirements
+ */
+async function requestContent(endpoint) {
+    console.log("\n Step 1: Request Content (without payment)");
+    console.log("─".repeat(50));
+    console.log(`  URL: ${SERVICE_URL}${endpoint}`);
+    const response = await fetch(`${SERVICE_URL}${endpoint}`);
+    if (response.status === 402) {
+        const data = (await response.json());
+        console.log(`  Status: 402 Payment Required ✅`);
+        // Find kite-testnet payment option (we'll use gokite-aa scheme to pay)
+        const kiteOption = data.accepts?.find((req) => req.network === "kite-testnet");
+        if (kiteOption) {
+            console.log(`  Payment options: ${data.accepts?.length || 0}`);
+            console.log(`  Selected: ${kiteOption.network} (using gokite-aa scheme)`);
+            console.log(`  Amount: ${ethers_1.ethers.formatUnits(kiteOption.maxAmountRequired, 18)} TestUSD`);
+            console.log(`  Pay to: ${kiteOption.payTo}`);
+            return kiteOption;
+        }
+        else {
+            console.log("  ❌ No kite-testnet payment option available");
+            console.log("  Available networks:", data.accepts?.map((r) => r.network).join(", "));
+            return null;
+        }
+    }
+    else if (response.ok) {
+        console.log("  ⚠️  Content returned without payment (unexpected)");
+        const content = await response.text();
+        console.log("  Content:", content.slice(0, 100));
+        return null;
+    }
+    else {
+        console.log(`  ❌ Unexpected status: ${response.status}`);
+        return null;
+    }
+}
+/**
+ * Step 2: Sign payment authorization
+ */
+async function signPayment(requirements) {
+    console.log("\n Step 2: Sign Payment Authorization");
+    console.log("─".repeat(50));
+    const nonce = ethers_1.ethers.hexlify((0, ethers_1.randomBytes)(32));
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const auth = {
+        from: AA_WALLET,
+        to: requirements.payTo,
+        token: requirements.asset,
+        value: BigInt(requirements.maxAmountRequired),
+        validAfter: now - 60n,
+        validBefore: now + 3600n,
+        nonce,
+    };
+    console.log(`  From: ${auth.from}`);
+    console.log(`  To: ${auth.to}`);
+    console.log(`  Token: ${auth.token}`);
+    console.log(`  Value: ${ethers_1.ethers.formatUnits(auth.value, 18)} TestUSD`);
+    console.log(`  Nonce: ${nonce.slice(0, 18)}...`);
+    const signature = await signTransferAuthorization(AA_WALLET, CHAIN_ID, auth);
+    console.log(`  Signature: ${signature.slice(0, 20)}...${signature.slice(-8)}`);
+    console.log("  ✅ Authorization signed");
+    const paymentPayload = {
+        x402Version: 1,
+        scheme: "gokite-aa",
+        network: requirements.network,
+        payload: {
+            signature,
+            authorization: {
+                from: auth.from,
+                to: auth.to,
+                token: auth.token,
+                value: auth.value.toString(),
+                validAfter: auth.validAfter.toString(),
+                validBefore: auth.validBefore.toString(),
+                nonce: auth.nonce,
+            },
+            sessionId: SESSION_ID,
+        },
+    };
+    return { paymentPayload, nonce };
+}
+/**
+ * Step 3: Send payment and get content
+ */
+async function buyContent(endpoint, paymentPayload) {
+    console.log("\n Step 3: Send Payment & Get Content");
+    console.log("─".repeat(50));
+    // Encode payment payload as base64
+    const xPayment = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
+    console.log(`  X-Payment header length: ${xPayment.length} chars`);
+    const response = await fetch(`${SERVICE_URL}${endpoint}`, {
+        headers: {
+            "X-Payment": xPayment,
+        },
+    });
+    console.log(`  Status: ${response.status}`);
+    if (response.ok) {
+        const contentType = response.headers.get("content-type");
+        let content;
+        if (contentType?.includes("application/json")) {
+            const json = await response.json();
+            content = JSON.stringify(json, null, 2);
+        }
+        else {
+            content = await response.text();
+        }
+        console.log("  ✅ Content received!");
+        return { success: true, content };
+    }
+    else {
+        const error = await response.text();
+        console.log("  ❌ Payment failed");
+        console.log("  Error:", error);
+        return { success: false, error };
+    }
+}
+// =============================================================================
+// Health Checks
+// =============================================================================
+async function checkFacilitator() {
+    console.log("\n🏥 Facilitator Health Check");
+    console.log("─".repeat(50));
+    console.log(`  URL: ${FACILITATOR_URL}`);
+    try {
+        const response = await fetch(`${FACILITATOR_URL}/health`);
+        if (response.ok) {
+            console.log("  ✅ Facilitator is healthy");
+            return true;
+        }
+        console.log(`  ❌ Status: ${response.status}`);
+        return false;
+    }
+    catch (error) {
+        console.log("  ❌ Connection failed:", error.message);
+        return false;
+    }
+}
+async function checkService() {
+    console.log("\n🏥 Service Health Check");
+    console.log("─".repeat(50));
+    console.log(`  URL: ${SERVICE_URL}`);
+    try {
+        const response = await fetch(`${SERVICE_URL}/health`);
+        if (response.ok) {
+            console.log("  ✅ Service is healthy");
+            return true;
+        }
+        console.log(`  ❌ Status: ${response.status}`);
+        return false;
+    }
+    catch (error) {
+        console.log("  ❌ Connection failed:", error.message);
+        return false;
+    }
+}
+// =============================================================================
+// Main Flow
+// =============================================================================
+async function main() {
+    const endpoint = process.argv[2] || "/protected-route";
+    console.log("═".repeat(60));
+    console.log("  x402 Gokite Payment Demo - Client");
+    console.log("═".repeat(60));
+    console.log("\n📍 Configuration");
+    console.log("─".repeat(50));
+    console.log(`  AA Wallet:   ${AA_WALLET}`);
+    console.log(`  Session ID:  ${SESSION_ID.slice(0, 18)}...`);
+    console.log(`  Agent:       ${agentSigner.address}`);
+    console.log(`  Service:     ${SERVICE_URL}`);
+    console.log(`  Endpoint:    ${endpoint}`);
+    //   // Health checks
+    //   const facilitatorOk = await checkFacilitator();
+    //   const serviceOk = await checkService();
+    //   if (!facilitatorOk || !serviceOk) {
+    //     console.error("\n❌ Health checks failed. Please ensure services are running:");
+    //     console.error("   1. Facilitator: cargo run (port 8080)");
+    //     console.error("   2. Service: cd examples/x402-axum-example && cargo run (port 8099)");
+    //     process.exit(1);
+    //   }
+    // Step 1: Request content (expect 402)
+    const requirements = await requestContent(endpoint);
+    if (!requirements) {
+        console.error("\n❌ Could not get payment requirements");
+        process.exit(1);
+    }
+    // Step 2: Sign payment
+    const { paymentPayload, nonce } = await signPayment(requirements);
+    // Step 3: Send payment and get content
+    const result = await buyContent(endpoint, paymentPayload);
+    // Summary
+    console.log("\n" + "═".repeat(60));
+    console.log("  Result");
+    console.log("═".repeat(60));
+    if (result.success) {
+        console.log("  ✅ Purchase successful!");
+        console.log("\n  Content:");
+        console.log("  " + "─".repeat(48));
+        console.log(result.content?.split("\n").map((l) => "  " + l).join("\n"));
+        console.log("  " + "─".repeat(48));
+        console.log(`\n  Payment nonce: ${nonce}`);
+        console.log("  (Nonce is now used - replay protection active)");
+    }
+    else {
+        console.log("  ❌ Purchase failed");
+        console.log(`  Error: ${result.error}`);
+    }
+    console.log("═".repeat(60));
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

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

@@ -1,127 +1,493 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * GokiteAccount E2E Demo with x402 Facilitator Integration
+ *
+ * This script demonstrates the complete AA wallet payment flow:
+ * 1. Setup AA wallet: addSupportedToken + setMasterBudgetRules
+ * 2. Create session with agent and spending rules
+ * 3. Agent signs EIP-712 transfer authorization
+ * 4. Verify payment via x402 facilitator
+ * 5. Settle payment via x402 facilitator (or direct UserOp execution)
+ *
+ * Usage:
+ *   npx tsx example-token-paymaster.ts [--settle] [--direct]
+ *
+ * Options:
+ *   --settle  Execute real settlement via facilitator
+ *   --direct  Execute direct UserOp instead of facilitator
+ */
 const ethers_1 = require("ethers");
 const gokite_aa_sdk_1 = require("./gokite-aa-sdk");
 require("dotenv/config");
+// =============================================================================
+// Configuration
+// =============================================================================
 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";
+// x402 Facilitator configuration
+const FACILITATOR_URL = process.env.FACILITATOR_URL || "http://localhost:8080";
+const X402_NETWORK = "kite-testnet";
+const CHAIN_ID = 2368;
 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)",
+// 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)",
     "function setSpendingRules(bytes32 sessionId, 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)",
 ]);
-const erc20Interface = new ethers_1.ethers.Interface([
-    "function transfer(address to, uint256 amount)",
-]);
-/**
- * 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
- */
-const PRIVATE_KEY = process.env.PRIVATE_KEY;
+// =============================================================================
+// Environment Setup
+// =============================================================================
+// 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")),
-            ],
+            targetProviders: [],
         },
     ];
 }
-function updatedRules() {
-    return [
+// =============================================================================
+// x402 Facilitator API Functions
+// =============================================================================
+async function facilitatorHealthCheck() {
+    console.log("\n[x402] Health Check");
+    console.log("=".repeat(50));
+    try {
+        const response = await fetch(`${FACILITATOR_URL}/health`);
+        const data = await response.json();
+        console.log("  Response:", JSON.stringify(data, null, 2));
+        console.log("  ✅ Facilitator is healthy!");
+        return true;
+    }
+    catch (error) {
+        console.error("  ❌ Health check failed:", error);
+        return false;
+    }
+}
+async function getSupportedNetworks() {
+    console.log("\n[x402] Supported Networks");
+    console.log("=".repeat(50));
+    try {
+        const response = await fetch(`${FACILITATOR_URL}/supported`);
+        const data = (await response.json());
+        console.log("  Response:", JSON.stringify(data, null, 2));
+        const kinds = data.kinds || [];
+        const hasKite = kinds.some((k) => k.network === X402_NETWORK);
+        if (hasKite) {
+            console.log("  ✅ Kite testnet is supported!");
+            return true;
+        }
+        else {
+            console.log("  ❌ Kite testnet NOT found in supported networks");
+            return false;
+        }
+    }
+    catch (error) {
+        console.error("  ❌ Failed to get supported networks:", error);
+        return false;
+    }
+}
+function buildVerifyRequest(authorization, signature, sessionIdHex, recipient) {
+    return {
+        x402Version: 1,
+        paymentPayload: {
+            x402Version: 1,
+            scheme: "gokite-aa",
+            network: X402_NETWORK,
+            payload: {
+                signature,
+                authorization,
+                sessionId: sessionIdHex,
+            },
+        },
+        paymentRequirements: {
+            scheme: "gokite-aa",
+            network: X402_NETWORK,
+            maxAmountRequired: authorization.value,
+            resource: "https://example.com/api",
+            description: "Test payment via AA wallet",
+            mimeType: "application/json",
+            payTo: recipient,
+            maxTimeoutSeconds: 30,
+            asset: authorization.token,
+        },
+    };
+}
+async function verifyPayment(request) {
+    console.log("\n[x402] Verify Payment");
+    console.log("=".repeat(50));
+    console.log("  Request:", JSON.stringify(request, null, 2));
+    try {
+        const response = await fetch(`${FACILITATOR_URL}/verify`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+        });
+        const data = (await response.json());
+        console.log("\n  Response:", JSON.stringify(data, null, 2));
+        if (data.isValid) {
+            console.log("\n  ✅ Verification PASSED!");
+        }
+        else {
+            console.log("\n  ❌ Verification FAILED:", data.invalidReason);
+        }
+        return data;
+    }
+    catch (error) {
+        console.error("  ❌ Verify request failed:", error);
+        return null;
+    }
+}
+async function settlePayment(request) {
+    console.log("\n[x402] Settle Payment");
+    console.log("=".repeat(50));
+    console.log("  Request:", JSON.stringify(request, null, 2));
+    try {
+        const response = await fetch(`${FACILITATOR_URL}/settle`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+        });
+        const data = (await response.json());
+        console.log("\n  Response:", JSON.stringify(data, null, 2));
+        if (data.success) {
+            console.log("\n  ✅ Settlement SUCCESSFUL!");
+            if (data.transaction) {
+                console.log("  Transaction Hash:", data.transaction);
+            }
+        }
+        else {
+            console.log("\n  ❌ Settlement FAILED:", data.errorReason);
+        }
+        return data;
+    }
+    catch (error) {
+        console.error("  ❌ Settle request failed:", error);
+        return null;
+    }
+}
+// =============================================================================
+// Query Functions
+// =============================================================================
+async function queryWalletStatus(aaWallet, provider) {
+    console.log("\n[Query] AA Wallet Status");
+    console.log("=".repeat(50));
+    // Check if wallet is deployed first
+    const code = await provider.getCode(aaWallet);
+    if (code === "0x") {
+        console.log(`  AA Wallet ${aaWallet} is not deployed yet (counterfactual address)`);
+        console.log(`  Wallet will be deployed on first UserOp execution`);
+        return { isDeployed: false, isSupported: false, balance: 0n };
+    }
+    const contract = new ethers_1.ethers.Contract(aaWallet, gokiteAccountInterface, provider);
+    // 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 { isDeployed: true, isSupported, balance };
+}
+async function querySessionStatus(aaWallet, sessionIdHex, 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(sessionIdHex);
+    console.log(`  Session ${sessionIdHex.slice(0, 18)}... exists: ${exists}`);
+    if (!exists)
+        return { exists };
+    // 2. Get session agent
+    const agent = await contract.getSessionAgent(sessionIdHex);
+    console.log(`  Session agent: ${agent}`);
+    // 3. Get spending rules
+    const spendingRules = await contract.getSpendingRules(sessionIdHex);
+    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}`);
+    }
+    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;
+}
+// =============================================================================
+// Main Flow
+// =============================================================================
+async function main() {
+    const args = process.argv.slice(2);
+    const shouldSettle = args.includes("--settle");
+    const useDirect = args.includes("--direct");
+    console.log("=".repeat(60));
+    console.log("GokiteAccount E2E Demo with x402 Facilitator");
+    console.log("=".repeat(60));
+    const aaWallet = sdk.getAccountAddress(ownerSigner.address);
+    const provider = new ethers_1.ethers.JsonRpcProvider(RPC_URL);
+    const chainId = (await provider.getNetwork()).chainId;
+    console.log("\nConfiguration:");
+    console.log("  Facilitator URL:", FACILITATOR_URL);
+    console.log("  Network:", X402_NETWORK);
+    console.log("  Chain ID:", CHAIN_ID);
+    console.log("  AA Wallet:", aaWallet);
+    console.log("  Owner:", ownerSigner.address);
+    console.log("  Agent:", agentSigner.address);
+    console.log("  Token:", SETTLEMENT_TOKEN);
+    console.log("  Mode:", useDirect ? "Direct UserOp" : "x402 Facilitator");
+    // ============ Query Wallet Status ============
+    const walletStatus = await queryWalletStatus(aaWallet, provider);
+    // ============ Step 1: Setup AA Wallet (only if not deployed) ============
+    if (!walletStatus.isDeployed) {
+        console.log("\n[Step 1] Setting up AA wallet...");
+        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 setupBatchData = gokiteAccountInterface.encodeFunctionData("executeBatch", [
+            [aaWallet],
+            [],
+            [masterBudgetData],
+        ]);
+        const setupTx = await sendWithTokenPayment(aaWallet, setupBatchData);
+        console.log(`  Setup (addSupportedToken + setMasterBudgetRules) tx: ${setupTx}`);
+        await new Promise((r) => setTimeout(r, 5000));
+    }
+    else {
+        console.log("\n[Step 1] AA wallet already deployed, skipping setup");
+    }
+    // ============ 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 2b: Update Spending Rules (setSpendingRules example) ============
+    console.log("\n[Step 2b] Updating session spending rules...");
+    // Define new spending rules to replace existing ones
+    const newSpendingRules = [
         {
-            timeWindow: 86400n,
+            timeWindow: BigInt(SECONDS_PER_DAY),
             budget: ethers_1.ethers.parseUnits("200", 18),
             initialWindowStartTime: currentDayStart(),
             targetProviders: [],
         },
         {
             timeWindow: 0n,
-            budget: ethers_1.ethers.parseUnits("5", 18),
+            budget: ethers_1.ethers.parseUnits("20", 18),
             initialWindowStartTime: 0n,
             targetProviders: [],
         },
+        {
+            timeWindow: BigInt(SECONDS_PER_DAY * 7),
+            budget: ethers_1.ethers.parseUnits("500", 18),
+            initialWindowStartTime: currentDayStart(),
+            targetProviders: [],
+        },
     ];
-}
-async function main() {
-    const aaWallet = sdk.getAccountAddress(signer.address);
-    const createSessionData = sessionInterface.encodeFunctionData("createSession", [
+    const setSpendingRulesData = gokiteAccountInterface.encodeFunctionData("setSpendingRules", [
         sessionId,
-        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 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),
+        newSpendingRules,
     ]);
-    const transferTx = await sendWithTokenPayment(SETTLEMENT_TOKEN, transferData);
-    console.log(`transfer tx: ${transferTx}`);
+    const setSpendingRulesTx = await sendWithTokenPayment(aaWallet, setSpendingRulesData);
+    console.log(`  setSpendingRules tx: ${setSpendingRulesTx}`);
+    await new Promise((r) => setTimeout(r, 5000));
+    // Query session status after updating spending rules
+    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.parseUnits("1", 18); // 1 token
+    // const nonce = ethers.hexlify(randomBytes(32));
+    // const now = BigInt(Math.floor(Date.now() / 1000));
+    // const auth = {
+    //   from: aaWallet,
+    //   to: recipient,
+    //   token: SETTLEMENT_TOKEN,
+    //   value: transferAmount,
+    //   validAfter: now - 60n, // valid from 1 minute ago
+    //   validBefore: now + 3600n, // valid for 1 hour
+    //   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 ============
+    // if (useDirect) {
+    //   // Direct UserOp execution
+    //   console.log("\n[Step 4] Executing transfer via direct UserOp...");
+    //   const executeTransferData = gokiteAccountInterface.encodeFunctionData(
+    //     "executeTransferWithAuthorization",
+    //     [sessionId, auth, signature]
+    //   );
+    //   const executeTx = await sendWithTokenPayment(aaWallet, executeTransferData);
+    //   console.log(`  executeTransferWithAuthorization tx: ${executeTx}`);
+    // } else {
+    //   // x402 Facilitator flow
+    //   console.log("\n[Step 4] Verifying via x402 facilitator...");
+    //   // Check facilitator health
+    //   const healthy = await facilitatorHealthCheck();
+    //   if (!healthy) {
+    //     console.error("\n❌ Facilitator not available, aborting");
+    //     process.exit(1);
+    //   }
+    //   // Check supported networks
+    //   await getSupportedNetworks();
+    //   // Build x402 request
+    //   const x402Auth: Authorization = {
+    //     from: aaWallet,
+    //     to: recipient,
+    //     token: SETTLEMENT_TOKEN,
+    //     value: transferAmount.toString(),
+    //     validAfter: auth.validAfter.toString(),
+    //     validBefore: auth.validBefore.toString(),
+    //     nonce: nonce,
+    //   };
+    //   const verifyRequest = buildVerifyRequest(x402Auth, signature, sessionId, recipient);
+    //   // Verify payment
+    //   const verifyResult = await verifyPayment(verifyRequest);
+    //   if (!verifyResult?.isValid) {
+    //     console.error("\n❌ Verification failed, skipping settle");
+    //     process.exit(1);
+    //   }
+    //   // Settle payment (optional)
+    //   if (shouldSettle) {
+    //     console.log("\n⚠️  Proceeding with REAL settlement transaction...");
+    //     const settleResult = await settlePayment(verifyRequest);
+    //     if (settleResult?.success && settleResult.transaction) {
+    //       console.log(`  Settlement tx: ${settleResult.transaction}`);
+    //     }
+    //   } else {
+    //     console.log("\n💡 Skipping settle (use --settle flag to execute real transaction)");
+    //   }
+    // }
+    // 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.d.ts

@@ -35,8 +35,13 @@ export declare class GokiteAASDK {
      * Build call data for batch transactions
      */
     buildBatchCallData(request: BatchUserOperationRequest): string;
+    /**
+     * Prepend addSupportedToken call to request for first transaction (wallet deployment)
+     */
+    private prependAddSupportedToken;
     /**
      * Create user operation
+     * If wallet is not deployed, automatically batch addSupportedToken into the first transaction
      */
     createUserOperation(owner: string, request: UserOperationRequest | BatchUserOperationRequest, salt?: bigint, paymasterAddress?: string, tokenAddress?: string): Promise<Partial<UserOperation>>;
     /**

package/dist/gokite-aa-sdk.js

@@ -251,16 +251,44 @@ class GokiteAASDK {
         const values = request.values || new Array(request.targets.length).fill(0n);
         return (0, utils_1.encodeFunctionCall)(['function executeBatch(address[],uint256[],bytes[])'], 'executeBatch', [request.targets, values, request.callDatas]);
     }
+    /**
+     * Prepend addSupportedToken call to request for first transaction (wallet deployment)
+     */
+    prependAddSupportedToken(request, accountAddress, tokenAddress) {
+        const addTokenCallData = (0, utils_1.encodeFunctionCall)(['function addSupportedToken(address)'], 'addSupportedToken', [tokenAddress]);
+        if ('target' in request) {
+            // Convert single request to batch with addSupportedToken prepended
+            return {
+                targets: [accountAddress, request.target],
+                values: [BigInt(0), request.value || BigInt(0)],
+                callDatas: [addTokenCallData, request.callData]
+            };
+        }
+        else {
+            // Prepend to existing batch
+            return {
+                targets: [accountAddress, ...request.targets],
+                values: [BigInt(0), ...(request.values || new Array(request.targets.length).fill(BigInt(0)))],
+                callDatas: [addTokenCallData, ...request.callDatas]
+            };
+        }
+    }
     /**
      * Create user operation
+     * If wallet is not deployed, automatically batch addSupportedToken into the first transaction
      */
     async createUserOperation(owner, request, salt, paymasterAddress, tokenAddress) {
         const actualSalt = salt || (0, utils_1.generateSalt)();
         const accountAddress = this.getAccountAddress(owner, actualSalt);
         const isDeployed = await this.isAccountDeloyed(accountAddress);
-        const callData = 'targets' in request
-            ? this.buildBatchCallData(request)
-            : this.buildCallData(request);
+        // If wallet not deployed, batch addSupportedToken into first transaction
+        let finalRequest = request;
+        if (!isDeployed && tokenAddress && tokenAddress !== '0x0000000000000000000000000000000000000000') {
+            finalRequest = this.prependAddSupportedToken(request, accountAddress, tokenAddress);
+        }
+        const callData = 'targets' in finalRequest
+            ? this.buildBatchCallData(finalRequest)
+            : this.buildCallData(finalRequest);
         // Gas settings (matching Go implementation)
         const callGasLimit = BigInt(300000);
         const verificationGasLimit = BigInt(300000);

package/dist/utils.js

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

package/package.json

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