@aastar/paymaster 0.16.8 → 0.16.12

package/dist/V4/BundlerCompat.d.ts

@@ -0,0 +1,28 @@
+import { type Address } from 'viem';
+/**
+ * Bundler types we support
+ */
+export declare enum BundlerType {
+    ALCHEMY = "alchemy",
+    PIMLICO = "pimlico",
+    STACKUP = "stackup",
+    CANDIDE = "candide",
+    UNKNOWN = "unknown"
+}
+/**
+ * Detect bundler type from URL
+ */
+export declare function detectBundlerType(bundlerUrl: string): BundlerType;
+/**
+ * Minimal interface to satisfy basic Pimlico/Bundler needs
+ * without bringing in heavy permissionless types that might conflict
+ */
+export interface BundlerConfig {
+    type: BundlerType;
+    url: string;
+    entryPoint: Address;
+}
+/**
+ * Create a bundler client config
+ */
+export declare function createBundlerClient(bundlerUrl: string, entryPoint: Address): BundlerConfig;

package/dist/V4/BundlerCompat.js

@@ -0,0 +1,37 @@
+/**
+ * Bundler types we support
+ */
+export var BundlerType;
+(function (BundlerType) {
+    BundlerType["ALCHEMY"] = "alchemy";
+    BundlerType["PIMLICO"] = "pimlico";
+    BundlerType["STACKUP"] = "stackup";
+    BundlerType["CANDIDE"] = "candide";
+    BundlerType["UNKNOWN"] = "unknown";
+})(BundlerType || (BundlerType = {}));
+/**
+ * Detect bundler type from URL
+ */
+export function detectBundlerType(bundlerUrl) {
+    const url = bundlerUrl.toLowerCase();
+    if (url.includes('alchemy.com'))
+        return BundlerType.ALCHEMY;
+    if (url.includes('pimlico.io'))
+        return BundlerType.PIMLICO;
+    if (url.includes('stackup'))
+        return BundlerType.STACKUP;
+    if (url.includes('candide.dev'))
+        return BundlerType.CANDIDE;
+    return BundlerType.UNKNOWN;
+}
+/**
+ * Create a bundler client config
+ */
+export function createBundlerClient(bundlerUrl, entryPoint) {
+    const bundlerType = detectBundlerType(bundlerUrl);
+    return {
+        type: bundlerType,
+        url: bundlerUrl,
+        entryPoint
+    };
+}

package/dist/{paymaster/src/V4 → V4}/PaymasterClient.d.ts

@@ -76,4 +76,9 @@ export declare class PaymasterClient {
      * This is the payload signed by the user.
      */
     static encodeExecution(target: Address, value: bigint, data: `0x${string}`): `0x${string}`;
+    /**
+     * More robust version of waitForUserOperationReceipt.
+     * Catches timeouts and returns a cleaner result.
+     */
+    static waitForUserOperation(bundlerClient: any, hash: `0x${string}`, timeout?: number): Promise<any>;
 }

package/dist/{paymaster/src/V4 → V4}/PaymasterClient.js

@@ -1,5 +1,6 @@
-import { concat, pad, toHex, parseAbi, encodeFunctionData } from 'viem';
-import { buildPaymasterData, buildSuperPaymasterData, formatUserOpV07, getUserOpHashV07 } from './PaymasterUtils';
+import { parseAbi, concat, pad, toHex, encodeFunctionData } from 'viem';
+import { buildPaymasterData, buildSuperPaymasterData, formatUserOpV07, getUserOpHashV07 } from './PaymasterUtils.js';
+import { detectBundlerType } from './BundlerCompat.js';
 /**
  * PaymasterClient
  * Focus: Integration, Funding, Interaction.
@@ -53,6 +54,44 @@ export class PaymasterClient {
      * Estimate Gas for a UserOperation.
      */
     static async estimateUserOperationGas(client, wallet, aaAddress, entryPoint, paymasterAddress, token, bundlerUrl, callData, options) {
+        // 0. Check cachedPrice (Critical for Paymaster V4)
+        if (!options?.operator) { // Only for Paymaster V4, not SuperPaymaster
+            try {
+                const cache = await client.readContract({
+                    address: paymasterAddress,
+                    abi: parseAbi(['function cachedPrice() view returns (uint208 price, uint48 updatedAt)']),
+                    functionName: 'cachedPrice'
+                });
+                if (!cache || cache.price === 0n || cache[0] === 0n) {
+                    console.log('[PaymasterClient] ⚠️  cachedPrice is 0! Auto-initializing...');
+                    // Check if we're on testnet (chainId 11155111 = Sepolia, 11155420 = OP Sepolia)
+                    const chainId = client.chain?.id || await client.getChainId();
+                    const isTestnet = [11155111, 11155420, 31337].includes(chainId);
+                    if (isTestnet) {
+                        // Auto-call updatePrice on testnet
+                        const updateHash = await wallet.writeContract({
+                            address: paymasterAddress,
+                            abi: parseAbi(['function updatePrice() external']),
+                            functionName: 'updatePrice'
+                        });
+                        await client.waitForTransactionReceipt({ hash: updateHash });
+                        console.log('[PaymasterClient] ✅ cachedPrice initialized via updatePrice()');
+                    }
+                    else {
+                        // Mainnet: throw error, require Keeper
+                        throw new Error(`Paymaster cachedPrice is 0 on Mainnet (chainId: ${chainId}). ` +
+                            `This requires Keeper to call updatePrice(). Please ensure Keeper is running.`);
+                    }
+                }
+            }
+            catch (e) {
+                // If error is our mainnet check, re-throw
+                if (e.message?.includes('requires Keeper'))
+                    throw e;
+                // Otherwise log and continue (might be old Paymaster without cachedPrice)
+                console.log('[PaymasterClient] ⚠️  Failed to check cachedPrice:', e.message?.slice(0, 50));
+            }
+        }
         // 1. Construct a dummy UserOp for estimation
         let paymasterAndData;
         if (options?.operator) {
@@ -64,8 +103,8 @@ export class PaymasterClient {
         else {
             paymasterAndData = buildPaymasterData(paymasterAddress, token, {
                 validityWindow: options?.validityWindow,
-                verificationGasLimit: 60000n, // Placeholder
-                postOpGasLimit: 60000n // Placeholder
+                verificationGasLimit: 250000n,
+                postOpGasLimit: 150000n
             });
         }
         // 1.5. Get dynamic gas prices from network
@@ -88,8 +127,8 @@ export class PaymasterClient {
                 ? concat([options.factory, options.factoryData])
                 : '0x',
             callData,
-            accountGasLimits: concat([pad(toHex(60000n), { size: 16 }), pad(toHex(100000n), { size: 16 })]), // 60k verification, 100k call
-            preVerificationGas: 50000n, // 50k PVG
+            accountGasLimits: concat([pad(toHex(250000n), { size: 16 }), pad(toHex(500000n), { size: 16 })]),
+            preVerificationGas: 100000n,
             gasFees: concat([pad(toHex(maxPriorityFeePerGas), { size: 16 }), pad(toHex(maxFeePerGas), { size: 16 })]),
             paymasterAndData,
             signature: '0x'
@@ -118,14 +157,33 @@ export class PaymasterClient {
             body: JSON.stringify(payload, (_, v) => typeof v === 'bigint' ? '0x' + v.toString(16) : v)
         });
         const result = await response.json();
+        // Debug logging for Candide
+        if (bundlerUrl.includes('candide')) {
+            console.log('[PaymasterClient] Candide Request:', JSON.stringify(payload.params[0], null, 2));
+            console.log('[PaymasterClient] Candide Response:', JSON.stringify(result, null, 2));
+        }
+        const data = result.result;
+        // Debug logging for estimation
+        console.log('[PaymasterClient] Gas Estimation Result:', JSON.stringify(data, null, 2));
+        // Anvil Fallback for Estimation
+        if (result.error && (result.error.code === -32601 || result.error.message?.includes('Method not found'))) {
+            console.log('[PaymasterClient] EstimateUserOp failed (Method not found). Using Anvil defaults.');
+            return {
+                preVerificationGas: 100000n,
+                verificationGasLimit: 1000000n,
+                callGasLimit: 2000000n,
+                paymasterVerificationGasLimit: 100000n,
+                paymasterPostOpGasLimit: 100000n
+            };
+        }
         if (result.error)
             throw new Error(`Estimation Error: ${JSON.stringify(result.error)}`);
-        const data = result.result;
-        // Dynamic tuning based on "Efficiency Guard" formulas
+        // Dynamic tuning: use estimated values directly to maintain efficiency
+        // Bundler efficiency check: actual_used / limit >= 0.4
         return {
             preVerificationGas: BigInt(data.preVerificationGas),
-            verificationGasLimit: BigInt(data.verificationGasLimit),
-            callGasLimit: (BigInt(data.callGasLimit) * 110n) / 100n, // 1.1x safety buffer
+            verificationGasLimit: BigInt(data.verificationGasLimit), // Use estimate as-is for efficiency
+            callGasLimit: (BigInt(data.callGasLimit) * 110n) / 100n, // Small 1.1x buffer
             paymasterVerificationGasLimit: data.paymasterVerificationGasLimit ? BigInt(data.paymasterVerificationGasLimit) : undefined,
             paymasterPostOpGasLimit: data.paymasterPostOpGasLimit ? BigInt(data.paymasterPostOpGasLimit) : 100000n
         };
@@ -141,7 +199,7 @@ export class PaymasterClient {
             verificationGasLimit: options?.verificationGasLimit,
             callGasLimit: options?.callGasLimit,
             paymasterVerificationGasLimit: options?.paymasterVerificationGasLimit,
-            paymasterPostOpGasLimit: options?.paymasterPostOpGasLimit ?? 100000n
+            paymasterPostOpGasLimit: options?.paymasterPostOpGasLimit ?? 150000n
         };
         if (options?.autoEstimate !== false && (!gasLimits.verificationGasLimit || !gasLimits.callGasLimit)) {
             const est = await this.estimateUserOperationGas(client, wallet, aaAddress, entryPoint, paymasterAddress, token, bundlerUrl, callData, {
@@ -198,9 +256,13 @@ export class PaymasterClient {
             });
         }
         else {
+            // MATH: Target Efficiency = PVG / (PVG + VGL + PMVGL) >= 0.4
+            // Since PVG is ~100k, (VGL + PMVGL) must be <= 150k.
+            // We set each to 75k to safely pass the 0.4 efficiency guard.
+            const pmVerGas = 75000n;
             paymasterAndData = buildPaymasterData(paymasterAddress, token, {
                 validityWindow: options?.validityWindow,
-                verificationGasLimit: gasLimits.paymasterVerificationGasLimit ?? gasLimits.verificationGasLimit ?? 150000n, // Use tuned value
+                verificationGasLimit: pmVerGas,
                 postOpGasLimit: gasLimits.paymasterPostOpGasLimit ?? 100000n
             });
         }
@@ -213,8 +275,8 @@ export class PaymasterClient {
                 : '0x',
             callData,
             accountGasLimits: concat([
-                pad(toHex(gasLimits.verificationGasLimit ?? 150000n), { size: 16 }), // Verification (Tuned or Default)
-                pad(toHex(gasLimits.callGasLimit ?? 500000n), { size: 16 }) // Call (Tuned or Default)
+                pad(toHex(75000n), { size: 16 }), // Verification (Tuned for 0.4 efficiency)
+                pad(toHex(gasLimits.callGasLimit ?? 500000n), { size: 16 }) // Call
             ]),
             preVerificationGas: gasLimits.preVerificationGas ?? 50000n,
             gasFees: concat([
@@ -237,7 +299,10 @@ export class PaymasterClient {
         const userOpHash = getUserOpHashV07(userOp, entryPoint, BigInt(client.chain.id));
         const signature = (await wallet.account.signMessage({ message: { raw: userOpHash } }));
         userOp.signature = signature;
-        // 6. Submit to Bundler
+        // 6. Submit to Bundler (Unified JSON-RPC)
+        const bundlerType = detectBundlerType(bundlerUrl);
+        console.log(`[PaymasterClient] Using ${bundlerType} Bundler`);
+        // Use standard JSON-RPC for all bundlers (Pimlico/Alchemy/Stackup/etc)
         const response = await fetch(bundlerUrl, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
@@ -249,8 +314,21 @@ export class PaymasterClient {
             }, (_, v) => typeof v === 'bigint' ? '0x' + v.toString(16) : v)
         });
         const result = await response.json();
+        if (result.error && (result.error.code === -32601 || result.error.message?.includes('Method not found'))) {
+            console.log('[PaymasterClient] SendUserOp failed (Method not found). Falling back to direct handleOps...');
+            const caller = wallet.account?.address ? wallet.account.address : wallet.account;
+            return await wallet.writeContract({
+                address: entryPoint,
+                abi: parseAbi(['function handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[], address) external']),
+                functionName: 'handleOps',
+                args: [[userOp], caller],
+                chain: wallet.chain,
+                account: wallet.account
+            });
+        }
         if (result.error)
             throw new Error(`Bundler Error: ${JSON.stringify(result.error)}`);
+        console.log('[PaymasterClient] ✅ Submitted via', bundlerType, 'hash:', result.result);
         return result.result;
     }
     /**
@@ -312,4 +390,19 @@ export class PaymasterClient {
             args: [target, value, data]
         });
     }
+    /**
+     * More robust version of waitForUserOperationReceipt.
+     * Catches timeouts and returns a cleaner result.
+     */
+    static async waitForUserOperation(bundlerClient, hash, timeout = 60000) {
+        try {
+            return await bundlerClient.waitForUserOperationReceipt({ hash, timeout });
+        }
+        catch (error) {
+            if (error.name === 'TimeoutError' || error.message?.includes('timed out')) {
+                return { timeout: true, hash };
+            }
+            throw error;
+        }
+    }
 }

package/dist/{paymaster/src/V4 → V4}/PaymasterUtils.d.ts

@@ -43,13 +43,24 @@ export declare function buildPaymasterData(paymasterAddress: Address, token: Add
 /**
  * Build paymasterAndData for SuperPaymaster V3.
  * Layout: [Paymaster(20)] [verGas(16)] [postGas(16)] [operator(20)] [maxRate(32)]
+ * Total: 104 bytes
+ *
+ * IMPORTANT: SuperPaymaster contract generates validUntil internally using:
+ *   validUntil = cachedPrice.updatedAt + priceStalenessThreshold
+ * Do NOT include validUntil/validAfter in paymasterAndData!
  */
 export declare function buildSuperPaymasterData(paymasterAddress: Address, operator: Address, options?: {
     verificationGasLimit?: bigint;
     postOpGasLimit?: bigint;
+    maxRate?: bigint;
 }): `0x${string}`;
 /**
  * Helper to format UserOp for Alchemy/Standard Bundlers (v0.7 Decomposed)
  */
 export declare function formatUserOpV07(userOp: any): any;
 export declare function getUserOpHashV07(userOp: any, entryPoint: Address, chainId: bigint): Hex;
+/**
+ * Tune gas limit using a dynamic nominal ceiling to satisfy Bundler efficiency (0.4)
+ * Target: Actual / Limit >= targetEfficiency
+ */
+export declare function tuneGasLimit(estimate: bigint, nominalActual: bigint, targetEfficiency?: number): bigint;

package/dist/{paymaster/src/V4 → V4}/PaymasterUtils.js

@@ -1,7 +1,6 @@
 import { concat, pad, toHex, keccak256, encodeAbiParameters, toBytes } from 'viem';
-import { validateAddress, validateUint128 } from '@aastar/core';
-const DEFAULT_VERIFICATION_GAS_V4 = 80000n;
-const DEFAULT_POSTOP_GAS_V4 = 100000n;
+const DEFAULT_VERIFICATION_GAS_V4 = 1500000n; // ~1.5M for safety
+const DEFAULT_POSTOP_GAS_V4 = 300000n; // ~300k for postOp logic
 /**
  * Constructs the middleware for Paymaster V4.
  * Returns the `paymasterAndData` hex string.
@@ -32,11 +31,8 @@ export function getPaymasterV4Middleware(config) {
  */
 export function buildPaymasterData(paymasterAddress, token, options) {
     const validityWindow = options?.validityWindow ?? 3600;
-    const verGas = options?.verificationGasLimit ?? 80000n;
+    const verGas = options?.verificationGasLimit ?? 200000n; // Increased for estimation
     const postGas = options?.postOpGasLimit ?? 100000n;
-    // Hardening: uint128 bounds check
-    validateUint128(verGas, 'verificationGasLimit');
-    validateUint128(postGas, 'postOpGasLimit');
     const now = Math.floor(Date.now() / 1000);
     const validUntil = now + validityWindow;
     const validAfter = now - 100; // 100 seconds grace period
@@ -52,20 +48,22 @@ export function buildPaymasterData(paymasterAddress, token, options) {
 /**
  * Build paymasterAndData for SuperPaymaster V3.
  * Layout: [Paymaster(20)] [verGas(16)] [postGas(16)] [operator(20)] [maxRate(32)]
+ * Total: 104 bytes
+ *
+ * IMPORTANT: SuperPaymaster contract generates validUntil internally using:
+ *   validUntil = cachedPrice.updatedAt + priceStalenessThreshold
+ * Do NOT include validUntil/validAfter in paymasterAndData!
  */
 export function buildSuperPaymasterData(paymasterAddress, operator, options) {
     const verGas = options?.verificationGasLimit ?? 80000n;
     const postGas = options?.postOpGasLimit ?? 100000n;
-    // Hardening
-    validateAddress(paymasterAddress, 'Paymaster Address');
-    validateAddress(operator, 'Operator Address');
-    validateUint128(verGas, 'verificationGasLimit');
-    validateUint128(postGas, 'postOpGasLimit');
+    const maxRate = options?.maxRate ?? ((1n << 256n) - 1n); // Default: max uint256, no rate limit
     return concat([
         paymasterAddress,
         pad(toHex(verGas), { size: 16 }),
         pad(toHex(postGas), { size: 16 }),
-        operator
+        operator,
+        pad(toHex(maxRate), { size: 32 }) // Optional rate commitment (rug pull protection)
     ]);
 }
 /**
@@ -77,14 +75,21 @@ export function formatUserOpV07(userOp) {
         nonce: toHex(userOp.nonce),
         callData: userOp.callData,
         preVerificationGas: toHex(userOp.preVerificationGas),
-        signature: userOp.signature,
-        initCode: userOp.initCode
+        signature: userOp.signature
     };
-    // Extract Factory/FactoryData if present
-    if (userOp.initCode && userOp.initCode !== '0x') {
-        result.factory = userOp.initCode.slice(0, 42);
-        result.factoryData = '0x' + userOp.initCode.slice(42);
+    // Only include factory/factoryData if account is NOT deployed (initCode not empty)
+    if (userOp.initCode && userOp.initCode !== '0x' && userOp.initCode.length > 2) {
+        result.initCode = userOp.initCode;
+        if (userOp.initCode.length > 42) {
+            result.factory = userOp.initCode.slice(0, 42);
+            result.factoryData = '0x' + userOp.initCode.slice(42);
+        }
+        else {
+            result.factory = '0x0000000000000000000000000000000000000000';
+            result.factoryData = '0x';
+        }
     }
+    // If account is deployed, don't include any factory fields at all
     // Unpack accountGasLimits: [verificationGasLimit(16)][callGasLimit(16)]
     if (userOp.accountGasLimits && userOp.accountGasLimits !== '0x') {
         const packed = userOp.accountGasLimits.replace('0x', '').padStart(64, '0');
@@ -122,3 +127,15 @@ export function getUserOpHashV07(userOp, entryPoint, chainId) {
     ]));
     return keccak256(encodeAbiParameters(['bytes32', 'address', 'uint256'].map(t => ({ type: t })), [hashedUserOp, entryPoint, chainId]));
 }
+/**
+ * Tune gas limit using a dynamic nominal ceiling to satisfy Bundler efficiency (0.4)
+ * Target: Actual / Limit >= targetEfficiency
+ */
+export function tuneGasLimit(estimate, nominalActual, targetEfficiency = 0.45) {
+    if (estimate === 0n)
+        return 0n;
+    // targetEfficiency = actual / ceiling => ceiling = actual / targetEfficiency
+    const ceiling = (nominalActual * 100n) / BigInt(Math.floor(targetEfficiency * 100));
+    // Return the more restrictive limit to ensure efficiency ratio is met
+    return estimate < ceiling ? estimate : ceiling;
+}

package/dist/{paymaster/src/V4 → V4}/SuperPaymasterClient.js

@@ -1,6 +1,6 @@
 import { encodeFunctionData, parseAbi } from 'viem';
 import { PaymasterClient } from './PaymasterClient';
-import { validateAddress, validateAmount } from '@aastar/core';
+import { tuneGasLimit } from './PaymasterUtils';
 /**
  * SuperPaymasterClient
  * High-level API for SuperPaymaster operations, including dynamic gas estimation.
@@ -11,12 +11,6 @@ export class SuperPaymasterClient {
      * Automatically handles gas estimation with a smart efficiency buffer.
      */
     static async submitGaslessTransaction(client, wallet, aaAddress, entryPoint, bundlerUrl, config) {
-        // Validation (Phase 0 Hardening)
-        validateAddress(config.token, 'Token Address');
-        validateAddress(config.recipient, 'Recipient Address');
-        validateAddress(config.operator, 'Operator Address');
-        validateAddress(config.paymasterAddress, 'Paymaster Address');
-        validateAmount(config.amount, 'Amount', 1n); // Must be > 0
         // 1. Prepare Calldata (Standard ERC20 Transfer)
         const callData = encodeFunctionData({
             abi: parseAbi(['function execute(address dest, uint256 value, bytes func) external']),
@@ -53,18 +47,30 @@ export class SuperPaymasterClient {
         // Safety Floor: If estimate is suspiciously low (e.g. < 50k), bump it for PM logic
         // But if we bump it too high, we hit "Efficiency too low".
         // Let's trust the bundler's estimate but add a fixed safety pad for dynamic storage
-        const SAFETY_PAD = 20000n;
+        const SAFETY_PAD = 80000n;
         const tunedVGL = vgl + SAFETY_PAD;
+        // CRITICAL FIX: Set paymasterVerificationGasLimit for optimal efficiency
+        // Bundler requires efficiency ratio >= 0.4 (actual_gas_used / gas_limit >= 0.4)
+        // SuperPaymaster validatePaymasterUserOp uses ~110-120k gas (measured)
+        // Test results:
+        // Analysis (Jan 19 Update-Final-Final):
+        //   Instead of fixed percentage, use "Dynamic Nominal Gas Tuning".
+        //   SuperPaymaster validation common case is ~58k-66k. Worst case (refresh) 115k.
+        //   Setting nominal benchmark to 60k gives Ceiling = 60k / 0.45 = 133,333.
+        //   This satisfies 0.4 efficiency (58/133=0.43) AND execution (115 < 133).
+        const bundlerEstimate = est.paymasterVerificationGasLimit || 100000n;
+        const tunedPMVerificationGas = tuneGasLimit(bundlerEstimate, 60000n, 0.45);
         // Same for PostOp
         const tunedPostOp = est.paymasterPostOpGasLimit + 10000n;
-        console.log(`[SuperPaymasterClient] 🔧 Tuned Limits: VGL=${tunedVGL}, PostOp=${tunedPostOp}`);
+        console.log(`[SuperPaymasterClient] 🔧 Tuned Limits: VGL=${tunedVGL}, PMVGL=${tunedPMVerificationGas}, PostOp=${tunedPostOp}`);
         // 4. Submit with Tuned Limits
         return PaymasterClient.submitGaslessUserOperation(client, wallet, aaAddress, entryPoint, config.paymasterAddress, config.token, bundlerUrl, callData, {
             operator: config.operator,
             verificationGasLimit: tunedVGL,
             callGasLimit: est.callGasLimit,
             preVerificationGas: est.preVerificationGas,
-            paymasterPostOpGasLimit: tunedPostOp, // Pass specific PM limits if supported
+            paymasterVerificationGasLimit: tunedPMVerificationGas, // EXPLICIT PM LIMIT
+            paymasterPostOpGasLimit: tunedPostOp,
             autoEstimate: false, // We did it ourselves
             factory: config.factory,
             factoryData: config.factoryData

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aastar/paymaster",
-  "version": "0.16.8",
+  "version": "0.16.12",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,18 +9,15 @@
   ],
   "dependencies": {
     "viem": "2.43.3",
-    "@aastar/core": "0.16.8"
+    "@aastar/core": "0.16.12"
   },
   "devDependencies": {
-    "typescript": "5.7.2"
+    "typescript": "5.6.3"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT",
   "scripts": {
     "clean": "find src -name '*.js' -o -name '*.d.ts' -o -name '*.map' | xargs rm -f",
     "prebuild": "pnpm clean",
-    "build": "tsc"
+    "build": "tsc",
+    "test": "vitest run"
   }
 }