@aastar/operator 0.16.11 → 0.16.12

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@aastar/operator",
-  "version": "0.16.11",
+  "version": "0.16.12",
   "description": "Operator client for AAstar SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "aastar",
     "operator",
@@ -13,7 +16,7 @@
   "license": "MIT",
   "dependencies": {
     "viem": "2.43.3",
-    "@aastar/core": "0.16.11"
+    "@aastar/core": "0.16.12"
   },
   "devDependencies": {
     "typescript": "5.7.2"

package/__tests__/PaymasterOperatorClient.test.ts

@@ -1,258 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { PaymasterOperatorClient } from '../src/PaymasterOperatorClient';
-import { createMockPublicClient, createMockWalletClient, resetMocks } from './mocks/client';
-import { parseEther } from 'viem';
-
-// Define mocks
-const mocks = vi.hoisted(() => {
-  const mockRegistry = { ROLE_COMMUNITY: vi.fn(), ROLE_PAYMASTER_SUPER: vi.fn(), ROLE_PAYMASTER_AOA: vi.fn(), hasRole: vi.fn(), registerRoleSelf: vi.fn() };
-  const mockToken = { allowance: vi.fn(), approve: vi.fn() };
-  const mockSuperPaymaster = { APNTS_TOKEN: vi.fn(), deposit: vi.fn(), configureOperator: vi.fn(), operators: vi.fn() };
-  const mockPaymasterFactory = { deployPaymaster: vi.fn(), getPaymaster: vi.fn() };
-  const mockPaymaster = { setTokenPrice: vi.fn(), tokenPrices: vi.fn(), depositFor: vi.fn() };
-
-  return {
-    mockRegistry,
-    mockToken,
-    mockSuperPaymaster,
-    mockPaymasterFactory,
-    mockPaymaster,
-    // Factory Functions
-    mockRegistryActions: vi.fn(() => () => mockRegistry),
-    mockTokenActions: vi.fn(() => () => mockToken),
-    mockSuperPaymasterActions: vi.fn(() => () => mockSuperPaymaster),
-    mockPaymasterFactoryActions: vi.fn(() => () => mockPaymasterFactory),
-    mockPaymasterActions: vi.fn(() => () => mockPaymaster),
-  };
-});
-
-vi.mock('@aastar/core', async () => {
-  const actual = await vi.importActual('@aastar/core');
-  return {
-    ...actual,
-    registryActions: mocks.mockRegistryActions,
-    tokenActions: mocks.mockTokenActions,
-    superPaymasterActions: mocks.mockSuperPaymasterActions,
-    paymasterFactoryActions: mocks.mockPaymasterFactoryActions,
-    paymasterActions: mocks.mockPaymasterActions,
-  };
-});
-
-vi.mock('viem', async () => {
-    const actual = await vi.importActual('viem');
-    return {
-        ...actual,
-        encodeFunctionData: vi.fn().mockReturnValue('0xInitData'),
-        // encodeAbiParameters: vi.fn().mockReturnValue('0xAbiData') // Use real implementation if possible, or mock carefully
-    };
-});
-
-describe('PaymasterOperatorClient', () => {
-  let client: PaymasterOperatorClient;
-  const mockPublicClient = createMockPublicClient();
-  const mockWalletClient = createMockWalletClient();
-
-  const config = {
-    params: { chainId: 11155111, rpcUrl: 'https://rpc.sepolia.org' },
-    services: {},
-    client: mockWalletClient as any,
-    superPaymasterAddress: '0x1111111111111111111111111111111111111111' as `0x${string}`,
-    tokenAddress: '0x2222222222222222222222222222222222222222' as `0x${string}`,
-    registryAddress: '0x3333333333333333333333333333333333333333' as `0x${string}`,
-    gTokenAddress: '0x4444444444444444444444444444444444444444' as `0x${string}`,
-    gTokenStakingAddress: '0x5555555555555555555555555555555555555555' as `0x${string}`,
-    paymasterFactoryAddress: '0x6666666666666666666666666666666666666666' as `0x${string}`,
-    entryPointAddress: '0x0000000071727De22E5E9d8BAf0edAc6f37da032' as `0x${string}`,
-  };
-
-  beforeEach(() => {
-    resetMocks();
-    vi.clearAllMocks();
-
-    // Default Mocks
-    mocks.mockRegistry.ROLE_COMMUNITY.mockResolvedValue('0x1111111111111111111111111111111111111111111111111111111111111111');
-    mocks.mockRegistry.ROLE_PAYMASTER_SUPER.mockResolvedValue('0x2222222222222222222222222222222222222222222222222222222222222222');
-    mocks.mockRegistry.ROLE_PAYMASTER_AOA.mockResolvedValue('0x3333333333333333333333333333333333333333333333333333333333333333');
-    mocks.mockRegistry.hasRole.mockResolvedValue(true); // Default has prerequisite
-    mocks.mockRegistry.registerRoleSelf.mockResolvedValue('0xTxHash');
-    mocks.mockToken.allowance.mockResolvedValue(parseEther('1000'));
-    mocks.mockToken.approve.mockResolvedValue('0xTxHash');
-    mocks.mockSuperPaymaster.APNTS_TOKEN.mockResolvedValue('0xAPNTS');
-    mocks.mockSuperPaymaster.deposit.mockResolvedValue('0xTxHash');
-    mocks.mockSuperPaymaster.configureOperator.mockResolvedValue('0xTxHash');
-    mocks.mockSuperPaymaster.operators.mockResolvedValue({
-        aPNTsBalance: 0n,
-        xPNTsToken: '0x2222222222222222222222222222222222222222',
-        treasury: '0x3333333333333333333333333333333333333333',
-        exchangeRate: 150n,
-        isConfigured: true,
-        isPaused: false,
-        reputation: 100,
-        minTxInterval: 60,
-        totalSpent: 0n,
-        totalTxSponsored: 0n
-    });
-    mocks.mockPaymasterFactory.deployPaymaster.mockResolvedValue('0xTxHash');
-    mocks.mockPaymasterFactory.getPaymaster.mockResolvedValue('0x7777777777777777777777777777777777777777');
-    mocks.mockPaymaster.setTokenPrice.mockResolvedValue('0xTxHash');
-    mocks.mockPaymaster.tokenPrices.mockResolvedValue(100n);
-    mocks.mockPaymaster.depositFor.mockResolvedValue('0xTxHash');
-
-    client = new PaymasterOperatorClient(config);
-    (client as any).client = mockWalletClient;
-    (client as any).publicClient = mockPublicClient;
-  });
-
-  describe('Registration', () => {
-    it('registerAsSuperPaymasterOperator should verify roles and register', async () => {
-        mocks.mockRegistry.hasRole
-            .mockResolvedValueOnce(true) // Has Community
-            .mockResolvedValueOnce(false); // Does not have SuperRole yet
-
-        await client.registerAsSuperPaymasterOperator({ stakeAmount: 100n });
-
-        expect(mocks.mockRegistry.registerRoleSelf).toHaveBeenCalledWith(expect.objectContaining({
-            roleId: '0x2222222222222222222222222222222222222222222222222222222222222222'
-        }));
-    });
-
-    it('registerAsSuperPaymasterOperator should throw if no community role', async () => {
-        mocks.mockRegistry.hasRole.mockResolvedValue(false);
-        await expect(client.registerAsSuperPaymasterOperator()).rejects.toThrow('Must have ROLE_COMMUNITY');
-    });
-
-    it('registerAsSuperPaymasterOperator should approve if needed', async () => {
-        mocks.mockRegistry.hasRole
-             .mockResolvedValueOnce(true)
-             .mockResolvedValueOnce(false);
-        mocks.mockToken.allowance.mockResolvedValue(0n);
-
-        await client.registerAsSuperPaymasterOperator({ stakeAmount: 100n });
-        
-        expect(mocks.mockToken.approve).toHaveBeenCalled();
-    });
-
-    it('registerAsSuperPaymasterOperator should handle optional deposit', async () => {
-        mocks.mockRegistry.hasRole
-             .mockResolvedValueOnce(true)
-             .mockResolvedValueOnce(false);
-        
-        await client.registerAsSuperPaymasterOperator({ depositAmount: 50n });
-        
-        expect(mocks.mockSuperPaymaster.deposit).toHaveBeenCalled();
-    });
-  });
-
-  describe('Deployment', () => {
-      it('deployAndRegisterPaymasterV4 should deploy and register', async () => {
-        // Mock role checks: Community exists, AOA doesn't
-        mocks.mockRegistry.hasRole.mockImplementation(async ({ roleId }: any) => {
-            if (roleId === '0x1111111111111111111111111111111111111111111111111111111111111111') return true;
-            if (roleId === '0x3333333333333333333333333333333333333333333333333333333333333333') return false;
-            return false;
-        });
-        
-        mocks.mockPaymasterFactory.getPaymaster.mockResolvedValueOnce('0x0000000000000000000000000000000000000000'); // Clean deploy
-        mocks.mockPaymasterFactory.getPaymaster.mockResolvedValueOnce('0x7777777777777777777777777777777777777777'); // After deploy
-
-        const result = await client.deployAndRegisterPaymasterV4();
-
-        expect(mocks.mockPaymasterFactory.deployPaymaster).toHaveBeenCalled();
-        expect(mocks.mockPaymasterFactory.getPaymaster).toHaveBeenCalled();
-        expect(mocks.mockRegistry.registerRoleSelf).toHaveBeenCalledWith(expect.objectContaining({
-            roleId: '0x3333333333333333333333333333333333333333333333333333333333333333'
-        }));
-        expect(result.paymasterAddress).toBe('0x7777777777777777777777777777777777777777');
-      });
-
-      it('deployAndRegisterPaymasterV4 should skip register if already has role', async () => {
-        // Mock getPaymaster to return existing address to exercise idempotency
-        mocks.mockPaymasterFactory.getPaymaster.mockResolvedValue('0x7777777777777777777777777777777777777777');
-        
-        mocks.mockRegistry.hasRole.mockImplementation(async ({ roleId }: any) => {
-            if (roleId === '0x1111111111111111111111111111111111111111111111111111111111111111') return true;
-            if (roleId === '0x3333333333333333333333333333333333333333333333333333333333333333') return true; // Already registered
-            return false;
-        });
-
-        const result = await client.deployAndRegisterPaymasterV4();
-        
-        expect(mocks.mockPaymasterFactory.deployPaymaster).not.toHaveBeenCalled();
-        expect(mocks.mockRegistry.registerRoleSelf).not.toHaveBeenCalled();
-        expect(result.registerHash).toBe('0x0000000000000000000000000000000000000000000000000000000000000000');
-      });
-  });
-
-  describe('Management', () => {
-      it('depositCollateral should approve and deposit', async () => {
-          mocks.mockToken.allowance.mockResolvedValue(0n);
-          await client.depositCollateral(100n);
-          
-          expect(mocks.mockSuperPaymaster.APNTS_TOKEN).toHaveBeenCalled();
-          expect(mocks.mockToken.approve).toHaveBeenCalled();
-          expect(mocks.mockSuperPaymaster.deposit).toHaveBeenCalledWith(expect.objectContaining({
-              amount: 100n
-          }));
-      });
-
-      it('updateExchangeRate should fetch config and call configureOperator', async () => {
-          // Mock operators return [balance, token, treasury, rate]
-          mocks.mockSuperPaymaster.operators.mockResolvedValue({
-              aPNTsBalance: 1000n,
-              xPNTsToken: '0x2222222222222222222222222222222222222222',
-              treasury: '0x3333333333333333333333333333333333333333',
-              exchangeRate: 150n,
-              isConfigured: true,
-              isPaused: false,
-              reputation: 100,
-              minTxInterval: 60,
-              totalSpent: 0n,
-              totalTxSponsored: 0n
-          });
-          mocks.mockSuperPaymaster.configureOperator.mockResolvedValue('0xTxHash');
-
-          await client.updateExchangeRate(200n);
-          
-          expect(mocks.mockSuperPaymaster.operators).toHaveBeenCalledWith(expect.objectContaining({
-              operator: '0x1234567890123456789012345678901234567890' // Default mock address from client.ts
-          }));
-          
-          expect(mocks.mockSuperPaymaster.configureOperator).toHaveBeenCalledWith(expect.objectContaining({
-              xPNTsToken: '0x2222222222222222222222222222222222222222',
-              opTreasury: '0x3333333333333333333333333333333333333333',
-              exchangeRate: 200n
-          }));
-      });
-  });
-
-  describe('Token Config', () => {
-      it('addGasToken should set token price', async () => {
-          await client.addGasToken('0x4444444444444444444444444444444444444444', 100n);
-          expect(mocks.mockPaymasterActions).toHaveBeenCalled(); // Should be called with SP address? No, superPaymasterAddress IS the paymaster for addGasToken (based on code reading)
-          // Wait, addGasToken uses paymasterActions(this.superPaymasterAddress)
-          expect(mocks.mockPaymasterActions).toHaveBeenCalledWith(config.superPaymasterAddress);
-          expect(mocks.mockPaymaster.setTokenPrice).toHaveBeenCalled();
-      });
-
-      it('getTokenPrice should read price', async () => {
-          const price = await client.getTokenPrice('0x4444444444444444444444444444444444444444');
-          expect(price).toBe(100n);
-      });
-  });
-
-  describe('Deposit', () => {
-      it('setupPaymasterDeposit should deposit for user', async () => {
-          await client.setupPaymasterDeposit({
-              paymaster: '0x5555555555555555555555555555555555555555',
-              user: '0x6666666666666666666666666666666666666666',
-              token: '0x4444444444444444444444444444444444444444',
-              amount: 100n
-          });
-          expect(mocks.mockPaymasterActions).toHaveBeenCalledWith('0x5555555555555555555555555555555555555555');
-          expect(mocks.mockPaymaster.depositFor).toHaveBeenCalledWith(expect.objectContaining({
-              user: '0x6666666666666666666666666666666666666666',
-              amount: 100n
-          }));
-      });
-  });
-});

package/__tests__/ProtocolClient.test.ts

@@ -1,135 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ProtocolClient } from '../src/ProtocolClient';
-import { createMockPublicClient, createMockWalletClient, resetMocks } from './mocks/client';
-
-// Define mocks using vi.hoisted
-const mocks = vi.hoisted(() => {
-  const mockDVT = { createSlashProposal: vi.fn(), signSlashProposal: vi.fn(), executeSlashWithProof: vi.fn() };
-  const mockAggregator = { registerBLSPublicKey: vi.fn() };
-  const mockSuperPaymaster = { setProtocolFee: vi.fn(), setTreasury: vi.fn() };
-  
-  return {
-    mockDVT,
-    mockAggregator,
-    mockSuperPaymaster,
-    // Factory functions
-    mockDVTActions: vi.fn(() => () => mockDVT),
-    mockAggregatorActions: vi.fn(() => () => mockAggregator),
-    mockSuperPaymasterActions: vi.fn(() => () => mockSuperPaymaster),
-  };
-});
-
-vi.mock('@aastar/core', async () => {
-  const actual = await vi.importActual('@aastar/core');
-  return {
-    ...actual,
-    dvtActions: mocks.mockDVTActions,
-    aggregatorActions: mocks.mockAggregatorActions,
-    superPaymasterActions: mocks.mockSuperPaymasterActions,
-  };
-});
-
-describe('ProtocolClient', () => {
-  let client: ProtocolClient;
-  const mockPublicClient = createMockPublicClient();
-  const mockWalletClient = createMockWalletClient();
-
-  const config = {
-    params: {
-        chainId: 11155111,
-        rpcUrl: 'https://rpc.sepolia.org',
-    },
-    services: {
-        paymasterUrl: 'https://paymaster.example.com',
-    },
-    client: mockWalletClient as any,
-    dvtValidatorAddress: '0x1111111111111111111111111111111111111111' as `0x${string}`,
-    blsAggregatorAddress: '0x2222222222222222222222222222222222222222' as `0x${string}`,
-    superPaymasterAddress: '0x3333333333333333333333333333333333333333' as `0x${string}`
-  };
-
-  beforeEach(() => {
-    resetMocks();
-    vi.clearAllMocks();
-
-    // Default Resolves
-    mocks.mockDVT.createSlashProposal.mockResolvedValue('0xTxHash');
-    mocks.mockDVT.signSlashProposal.mockResolvedValue('0xTxHash');
-    mocks.mockDVT.executeSlashWithProof.mockResolvedValue('0xTxHash');
-    mocks.mockAggregator.registerBLSPublicKey.mockResolvedValue('0xTxHash');
-    mocks.mockSuperPaymaster.setProtocolFee.mockResolvedValue('0xTxHash');
-    mocks.mockSuperPaymaster.setTreasury.mockResolvedValue('0xTxHash');
-
-    client = new ProtocolClient(config);
-    (client as any).client = mockWalletClient;
-    (client as any).publicClient = mockPublicClient;
-  });
-
-  describe('DVT Proposals', () => {
-    it('createProposal should call createSlashProposal', async () => {
-      const result = await client.createProposal('0x4444444444444444444444444444444444444444', '0x1234', 'Description');
-      
-      expect(mocks.mockDVTActions).toHaveBeenCalledWith(config.dvtValidatorAddress);
-      expect(mocks.mockDVT.createSlashProposal).toHaveBeenCalledWith(expect.objectContaining({
-          operator: '0x4444444444444444444444444444444444444444',
-          level: 1,
-          reason: 'Description'
-      }));
-      expect(result).toBe('0xTxHash');
-    });
-
-    it('signProposal should call signSlashProposal', async () => {
-        await client.signProposal(1n, '0x5555');
-        expect(mocks.mockDVT.signSlashProposal).toHaveBeenCalledWith(expect.objectContaining({
-            proposalId: 1n,
-            signature: '0x5555'
-        }));
-    });
-
-    it('executeWithProof should call executeSlashWithProof', async () => {
-        await client.executeWithProof(1n, ['0x5555']);
-        expect(mocks.mockDVT.executeSlashWithProof).toHaveBeenCalledWith(expect.objectContaining({
-            proposalId: 1n,
-            // proof is mocked inside implementation
-        }));
-    });
-  });
-
-  describe('BLS Management', () => {
-      it('registerBLSKey should call registerBLSPublicKey', async () => {
-          await client.registerBLSKey('0x123456');
-          expect(mocks.mockAggregatorActions).toHaveBeenCalledWith(config.blsAggregatorAddress);
-          expect(mocks.mockAggregator.registerBLSPublicKey).toHaveBeenCalledWith(expect.objectContaining({
-              publicKey: '0x123456'
-          }));
-      });
-
-      it('should throw if blsAggregatorAddress missing', async () => {
-          client.blsAggregatorAddress = undefined;
-          await expect(client.registerBLSKey('0x12')).rejects.toThrow('BLS Aggregator address required');
-      });
-  });
-
-  describe('Global Params', () => {
-      it('setProtocolFee should call superPaymaster', async () => {
-          await client.setProtocolFee(100n);
-          expect(mocks.mockSuperPaymasterActions).toHaveBeenCalledWith(config.superPaymasterAddress);
-          expect(mocks.mockSuperPaymaster.setProtocolFee).toHaveBeenCalledWith(expect.objectContaining({
-              newFeeBPS: 100n
-          }));
-      });
-
-      it('setTreasury should call superPaymaster', async () => {
-          await client.setTreasury('0x7777777777777777777777777777777777777777');
-          expect(mocks.mockSuperPaymaster.setTreasury).toHaveBeenCalledWith(expect.objectContaining({
-              treasury: '0x7777777777777777777777777777777777777777'
-          }));
-      });
-
-      it('should throw if superPaymasterAddress missing', async () => {
-          client.superPaymasterAddress = undefined;
-          await expect(client.setTreasury('0x1111111111111111111111111111111111111111')).rejects.toThrow('SuperPaymaster address required');
-      });
-  });
-
-});

package/__tests__/index.test.ts

@@ -1,16 +0,0 @@
-
-import { PaymasterOperatorClient } from '../src/PaymasterOperatorClient';
-import { ProtocolClient } from '../src/ProtocolClient';
-import * as Exports from '../src/index';
-
-describe('Operator Package Exports', () => {
-    it('should export PaymasterOperatorClient', () => {
-        expect(Exports.PaymasterOperatorClient).toBeDefined();
-        expect(Exports.PaymasterOperatorClient).toBe(PaymasterOperatorClient);
-    });
-
-    it('should export ProtocolClient', () => {
-        expect(Exports.ProtocolClient).toBeDefined();
-        expect(Exports.ProtocolClient).toBe(ProtocolClient);
-    });
-});

package/__tests__/mocks/client.ts

@@ -1,22 +0,0 @@
-import { vi } from 'vitest';
-import type { PublicClient, WalletClient } from 'viem';
-
-export const createMockPublicClient = (): PublicClient => {
-  return {
-    readContract: vi.fn(),
-    chain: { id: 11155111 },
-    waitForTransactionReceipt: vi.fn().mockResolvedValue({ status: 'success' }),
-  } as any;
-};
-
-export const createMockWalletClient = (): WalletClient => {
-  return {
-    writeContract: vi.fn(),
-    account: { address: '0x1234567890123456789012345678901234567890' },
-    chain: { id: 11155111 },
-  } as any;
-};
-
-export const resetMocks = () => {
-  vi.clearAllMocks();
-};

package/src/PaymasterOperatorClient.ts

@@ -1,454 +0,0 @@
-import { type Address, type Hash, parseEther } from 'viem';
-import { BaseClient, type ClientConfig, type TransactionOptions, PaymasterABI } from '@aastar/core';
-import { superPaymasterActions, tokenActions, paymasterActions, registryActions, paymasterFactoryActions } from '@aastar/core';
-
-export interface OperatorClientConfig extends ClientConfig {
-    superPaymasterAddress: Address;
-    tokenAddress?: Address;
-}
-
-export interface SponsorshipPolicy {
-    globalLimit: bigint;
-    userLimit: bigint;
-    itemPrice: bigint;
-    // ... logic for encoding this into bytes/storage
-}
-
-/**
- * Client for Paymaster Operators (ROLE_PAYMASTER_SUPER)
- */
-export class PaymasterOperatorClient extends BaseClient {
-    public superPaymasterAddress: Address;
-    public tokenAddress?: Address;
-    public ethUsdPriceFeed: Address;
-    public xpntsFactory: Address;
-
-    constructor(config: OperatorClientConfig) {
-        super(config);
-        this.superPaymasterAddress = config.superPaymasterAddress;
-        this.tokenAddress = config.tokenAddress;
-        this.ethUsdPriceFeed = config.ethUsdPriceFeedAddress || '0x694AA1769357215DE4FAC081bf1f309aDC325306'; // Default Sepolia
-        this.xpntsFactory = config.xpntsFactoryAddress || '0x0000000000000000000000000000000000000000'; // Should be provided
-    }
-
-    // ========================================
-    // 0. 注册与入驻 (One-Stop Registration)
-    // ========================================
-
-    /**
-     * Register as SuperPaymaster Operator (one-stop API).
-     * This method handles all necessary steps:
-     * 1. Checks prerequisites (must have ROLE_COMMUNITY)
-     * 2. Checks and approves GToken to GTokenStaking
-     * 3. Registers ROLE_PAYMASTER_SUPER
-     * 4. Optionally deposits collateral to SuperPaymaster
-     * 
-     * @param params Registration parameters
-     * @param options Transaction options
-     * @returns Transaction hash of role registration
-     */
-    async registerAsSuperPaymasterOperator(params?: {
-        stakeAmount?: bigint; // Optional, defaults to 50 GToken (Registry requirement)
-        depositAmount?: bigint; // Optional initial deposit to SuperPaymaster
-    }, options?: TransactionOptions): Promise<Hash> {
-        try {
-            const registryAddr = this.requireRegistry();
-            const gTokenAddr = this.requireGToken();
-            const gTokenStakingAddr = this.requireGTokenStaking();
-            
-            const registry = registryActions(registryAddr);
-            const gToken = tokenActions();
-            const publicClient = this.getStartPublicClient();
-            
-            // 1. Check prerequisites
-            const ROLE_COMMUNITY = await registry(publicClient).ROLE_COMMUNITY();
-            const hasCommunity = await registry(publicClient).hasRole({
-                user: this.getAddress(),
-                roleId: ROLE_COMMUNITY
-            });
-            
-            if (!hasCommunity) {
-                throw new Error('Must have ROLE_COMMUNITY before registering as SuperPaymaster operator');
-            }
-            
-            // 2. Check if already has role
-            const ROLE_PAYMASTER_SUPER = await registry(publicClient).ROLE_PAYMASTER_SUPER();
-            const hasSuper = await registry(publicClient).hasRole({
-                user: this.getAddress(),
-                roleId: ROLE_PAYMASTER_SUPER
-            });
-            
-            if (hasSuper) {
-                // Still handle deposit if requested
-                if (params?.depositAmount) {
-                    return this.depositCollateral(params.depositAmount, options);
-                }
-                throw new Error('Already registered as SuperPaymaster operator');
-            }
-            
-            // 3. Prepare stake amount (default 50 GToken as per Registry config)
-            const stakeAmount = params?.stakeAmount || parseEther('50');
-            
-            // 4. Check and approve GToken to GTokenStaking
-            const allowance = await gToken(publicClient).allowance({
-                token: gTokenAddr,
-                owner: this.getAddress(),
-                spender: gTokenStakingAddr
-            });
-            
-            if (allowance < stakeAmount) {
-                const approveHash = await gToken(this.client).approve({
-                    token: gTokenAddr,
-                    spender: gTokenStakingAddr,
-                    amount: stakeAmount * 2n, // Approve 2x for future use
-                    account: options?.account
-                });
-                await (publicClient as any).waitForTransactionReceipt({ hash: approveHash });
-            }
-            
-            // 5. Register ROLE_PAYMASTER_SUPER
-            const registerHash = await registry(this.client).registerRoleSelf({
-                roleId: ROLE_PAYMASTER_SUPER,
-                data: '0x', // SuperPaymaster role doesn't need special data
-                account: options?.account
-            });
-            
-            // Wait for registration to complete
-            await (publicClient as any).waitForTransactionReceipt({ hash: registerHash });
-            
-            // 6. Optional: Deposit collateral to SuperPaymaster
-            if (params?.depositAmount) {
-                await this.depositCollateral(params.depositAmount, options);
-            }
-            
-            return registerHash;
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    /**
-     * Deploy a new Paymaster V4 and Register as AOA Operator (one-stop API).
-     * This method handles:
-     * 1. Checks prerequisites (ROLE_COMMUNITY)
-     * 2. Predicts new Paymaster address
-     * 3. Deploys Paymaster V4 via Factory
-     * 4. Registers ROLE_PAYMASTER_AOA with staking
-     * 
-     * @param params Deployment parameters
-     * @param options Transaction options
-     * @returns Object containing new paymaster address and transaction hashes
-     */
-    async deployAndRegisterPaymasterV4(params?: {
-        stakeAmount?: bigint; // Optional, defaults to 30 GToken (Registry requirement for AOA)
-        version?: string; // Optional, defaults to Factory default or V4.0.0
-        salt?: bigint; // Optional, for deterministic deployment
-    }, options?: TransactionOptions): Promise<{ 
-        paymasterAddress: Address; 
-        deployHash: Hash; 
-        registerHash: Hash;
-    }> {
-        try {
-            const registryAddr = this.requireRegistry();
-            const gTokenAddr = this.requireGToken();
-            const gTokenStakingAddr = this.requireGTokenStaking();
-            const factoryAddr = this.requirePaymasterFactory();
-            
-            const registry = registryActions(registryAddr);
-            const gToken = tokenActions();
-            const factory = paymasterFactoryActions(factoryAddr);
-            const publicClient = this.getStartPublicClient();
-            
-            const account = options?.account || this.client.account || this.getAddress();
-            const accountAddr = typeof account === 'string' ? account : account.address;
-
-            // 1. Check prerequisites (ROLE_COMMUNITY)
-            const ROLE_COMMUNITY = await registry(publicClient).ROLE_COMMUNITY();
-            const hasCommunity = await registry(publicClient).hasRole({
-                user: accountAddr,
-                roleId: ROLE_COMMUNITY
-            });
-            
-            if (!hasCommunity) {
-                throw new Error('Must have ROLE_COMMUNITY before deploying Paymaster V4');
-            }
-
-            // 2. Deployment (Idempotent Check)
-            const existingPaymaster = await factory(publicClient).getPaymaster({ owner: accountAddr });
-            let deployHash: Hash = '0x0000000000000000000000000000000000000000000000000000000000000000';
-            let paymasterAddress: Address;
-
-            if (existingPaymaster && existingPaymaster !== '0x0000000000000000000000000000000000000000') {
-                console.log(`    ℹ️  Paymaster already deployed at: ${existingPaymaster}`);
-                paymasterAddress = existingPaymaster;
-            } else {
-                console.log('    🛠️ Deploying Paymaster V4 with args:', {
-                    entryPoint: this.requireEntryPoint(),
-                    owner: accountAddr,
-                    priceFeed: this.ethUsdPriceFeed,
-                    factory: factoryAddr
-                });
-
-                const { encodeFunctionData } = await import('viem');
-                const initData = encodeFunctionData({
-                    abi: PaymasterABI,
-                    functionName: 'initialize',
-                    args: [
-                        this.requireEntryPoint(), // EntryPoint v0.7
-                        accountAddr,
-                        accountAddr, // Treasury defaults to owner
-                        this.ethUsdPriceFeed,
-                        200n, // serviceFeeRate (2%)
-                        parseEther('0.1'), // maxGasCostCap
-                        3600n // priceStalenessThreshold
-                    ]
-                });
-
-                deployHash = await factory(this.client).deployPaymaster({
-                    version: params?.version, 
-                    initData,
-                    account
-                });
-                
-                await (publicClient as any).waitForTransactionReceipt({ hash: deployHash });
-                
-                paymasterAddress = await factory(publicClient).getPaymaster({ owner: accountAddr });
-            }
-            
-            if (!paymasterAddress || paymasterAddress === '0x0000000000000000000000000000000000000000') {
-                 throw new Error('Failed to retrieve Paymaster address from Factory');
-            }
-
-            // 3. Register ROLE_PAYMASTER_AOA
-            const ROLE_PAYMASTER_AOA = await registry(publicClient).ROLE_PAYMASTER_AOA();
-            const hasAOA = await registry(publicClient).hasRole({
-                user: accountAddr,
-                roleId: ROLE_PAYMASTER_AOA
-            });
-
-            if (hasAOA) {
-                return { paymasterAddress, deployHash, registerHash: '0x0000000000000000000000000000000000000000000000000000000000000000' };
-            }
-
-            const stakeAmount = params?.stakeAmount || parseEther('30');
-            
-            const allowance = await gToken(publicClient).allowance({
-                token: gTokenAddr,
-                owner: accountAddr,
-                spender: gTokenStakingAddr
-            });
-            
-            if (allowance < stakeAmount) {
-                const approveHash = await gToken(this.client).approve({
-                    token: gTokenAddr,
-                    spender: gTokenStakingAddr,
-                    amount: stakeAmount * 2n,
-                    account: account
-                });
-                await (publicClient as any).waitForTransactionReceipt({ hash: approveHash });
-            }
-
-            const { encodeAbiParameters, parseAbiParameters } = await import('viem');
-            let roleData: Hash = '0x';
-            if (stakeAmount > 0) {
-                roleData = encodeAbiParameters(
-                    parseAbiParameters('uint256'),
-                    [stakeAmount]
-                ) as Hash;
-            }
-
-            const registerHash = await registry(this.client).registerRoleSelf({
-                roleId: ROLE_PAYMASTER_AOA,
-                data: roleData,
-                account: account
-            });
-            
-            await (publicClient as any).waitForTransactionReceipt({ hash: registerHash });
-
-            return {
-                paymasterAddress,
-                deployHash,
-                registerHash
-            };
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    /**
-     * Deposit collateral (aPNTs/GToken) to SuperPaymaster.
-     * This is a helper method used by registerAsSuperPaymasterOperator.
-     */
-    async depositCollateral(amount: bigint, options?: TransactionOptions): Promise<Hash> {
-        try {
-            const pm = superPaymasterActions(this.superPaymasterAddress);
-            const publicClient = this.getStartPublicClient();
-            
-            // V3.7: Dynamically fetch the token expected by SuperPaymaster
-            const depositToken = await pm(publicClient).APNTS_TOKEN();
-            const token = tokenActions();
-            
-            // Approve SuperPaymaster to spend the token (usually aPNTs on Sepolia)
-            const allowance = await token(publicClient).allowance({
-                token: depositToken,
-                owner: this.getAddress(),
-                spender: this.superPaymasterAddress
-            });
-            
-            if (allowance < amount) {
-                const approveHash = await token(this.client).approve({
-                    token: depositToken,
-                    spender: this.superPaymasterAddress,
-                    amount,
-                    account: options?.account
-                });
-                await (publicClient as any).waitForTransactionReceipt({ hash: approveHash });
-            }
-            
-            // Deposit to SuperPaymaster
-            return pm(this.client).deposit({
-                amount,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async updateExchangeRate(exchangeRate: bigint, options?: TransactionOptions): Promise<Hash> {
-        return this.configureOperator(undefined, undefined, exchangeRate, options);
-    }
-
-    /**
-     * Configure operator parameters (Token, Treasury, Exchange Rate).
-     * If parameters are undefined, existing values are preserved.
-     */
-    async configureOperator(
-        xPNTsToken?: Address, 
-        treasury?: Address, 
-        exchangeRate?: bigint, 
-        options?: TransactionOptions
-    ): Promise<Hash> {
-        try {
-            const sp = superPaymasterActions(this.superPaymasterAddress);
-            const publicClient = this.getStartPublicClient();
-
-            // Fetch current config to preserve missing values
-            const currentConfig = await sp(publicClient).operators({ operator: this.getAddress() });
-            
-            const currentToken = currentConfig.xPNTsToken;
-            const currentTreasury = currentConfig.treasury;
-            const currentRate = currentConfig.exchangeRate;
-
-            return await sp(this.client).configureOperator({
-                xPNTsToken: xPNTsToken || currentToken,
-                opTreasury: treasury || currentTreasury,
-                exchangeRate: exchangeRate ?? currentRate,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async withdrawCollateral(to: Address, amount: bigint, options?: TransactionOptions): Promise<Hash> {
-        try {
-            const sp = superPaymasterActions(this.superPaymasterAddress);
-            return await sp(this.client).withdrawTo({
-                to,
-                amount,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async isOperator(operator: Address): Promise<boolean> {
-        try {
-            const sp = superPaymasterActions(this.superPaymasterAddress);
-            const config = await sp(this.getStartPublicClient()).operators({ operator });
-            return config.isConfigured;
-        } catch (error) {
-            return false;
-        }
-    }
-
-    async getOperatorDetails(operator?: Address): Promise<any> {
-        try {
-            const target = operator || this.getAddress();
-            const sp = superPaymasterActions(this.superPaymasterAddress);
-            return await sp(this.getStartPublicClient()).operators({ operator: target });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async initiateExit(options?: TransactionOptions): Promise<Hash> {
-        try {
-            const sp = superPaymasterActions(this.superPaymasterAddress);
-            return await sp(this.client).unlockStake({
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async withdrawStake(to: Address, options?: TransactionOptions): Promise<Hash> {
-        try {
-            const sp = superPaymasterActions(this.superPaymasterAddress);
-            return await sp(this.client).withdrawStake({
-                to,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    // ========================================
-    // 3. 支付代币管理 (基于 PaymasterActions)
-    // ========================================
-
-    async addGasToken(token: Address, price: bigint, options?: TransactionOptions): Promise<Hash> {
-        try {
-            const pm = paymasterActions(this.superPaymasterAddress);
-            return await pm(this.client).setTokenPrice({
-                token,
-                price,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async getTokenPrice(token: Address): Promise<bigint> {
-        try {
-            const pm = paymasterActions(this.superPaymasterAddress);
-            return await pm(this.getStartPublicClient()).tokenPrices({ token });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async setupPaymasterDeposit(params: {
-        paymaster: Address;
-        user: Address;
-        token: Address;
-        amount: bigint;
-    }, options?: TransactionOptions): Promise<Hash> {
-        try {
-            const pm = paymasterActions(params.paymaster);
-            return await pm(this.client).depositFor({
-                user: params.user,
-                token: params.token,
-                amount: params.amount,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-}

package/src/ProtocolClient.ts

@@ -1,154 +0,0 @@
-import { type Address, type Hash, type Hex } from 'viem';
-import { BaseClient, type ClientConfig, type TransactionOptions } from '@aastar/core';
-import { dvtActions, aggregatorActions, superPaymasterActions } from '@aastar/core';
-
-export interface ProtocolClientConfig extends ClientConfig {
-    dvtValidatorAddress: Address; // The DVT Validator contract (Governance)
-    blsAggregatorAddress?: Address; // Optional BLS Aggregator
-    superPaymasterAddress?: Address; // For Global Params
-}
-
-export enum ProposalState {
-    Pending = 0,
-    Active = 1,
-    Canceled = 2,
-    Defeated = 3,
-    Succeeded = 4,
-    Queued = 5,
-    Expired = 6,
-    Executed = 7
-}
-
-/**
- * Client for Protocol Governors and Validators (Infrastructure)
- */
-export class ProtocolClient extends BaseClient {
-    public dvtValidatorAddress: Address;
-    public blsAggregatorAddress?: Address;
-    public superPaymasterAddress?: Address;
-
-    constructor(config: ProtocolClientConfig) {
-        super(config);
-        this.dvtValidatorAddress = config.dvtValidatorAddress;
-        this.blsAggregatorAddress = config.blsAggregatorAddress;
-        this.superPaymasterAddress = config.superPaymasterAddress;
-    }
-
-    // ========================================
-    // 1. 提案管理 (DVT)
-    // ========================================
-
-    /**
-     * Create a new proposal
-     */
-    async createProposal(target: Address, calldata: Hex, description: string, options?: TransactionOptions): Promise<Hash> {
-        try {
-            const dvt = dvtActions(this.dvtValidatorAddress)(this.client);
-            
-            // Mapping general "createProposal" to "createSlashProposal" for now
-            // Assuming Governance uses Validator logic or this Client is for Slash.
-            // Using createSlashProposal as the available action.
-            return await dvt.createSlashProposal({
-                operator: target,
-                level: 1, // Default level
-                reason: description,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async signProposal(proposalId: bigint, signature: Hex = '0x', options?: TransactionOptions): Promise<Hash> {
-        try {
-            const dvt = dvtActions(this.dvtValidatorAddress)(this.client);
-            return await dvt.signSlashProposal({
-                proposalId,
-                signature,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    /**
-     * Execute a proposal with collected signatures
-     */
-    async executeWithProof(proposalId: bigint, signatures: Hex[], options?: TransactionOptions): Promise<Hash> {
-        try {
-            // Mock proof generation logic or placeholder
-            const proof = '0x' as Hex; 
-            const dvt = dvtActions(this.dvtValidatorAddress)(this.client);
-            
-            return await dvt.executeSlashWithProof({
-                proposalId,
-                repUsers: [], // Needs real data in production
-                newScores: [],
-                epoch: 0n,
-                proof,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    // ========================================
-    // 2. 验证器管理 / BLS
-    // ========================================
-
-    async registerBLSKey(publicKey: Hex, options?: TransactionOptions): Promise<Hash> {
-        try {
-            if (!this.blsAggregatorAddress) {
-                throw new Error('BLS Aggregator address required for this client');
-            }
-            // Aggregator actions now handle the type internally or via mapping
-            const agg = aggregatorActions(this.blsAggregatorAddress)(this.client);
-            
-            return await agg.registerBLSPublicKey({
-                validator: this.getAddress(),
-                publicKey,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    // ========================================
-    // 3. 全局参数管理 (Admin)
-    // ========================================
-
-    async setProtocolFee(bps: bigint, options?: TransactionOptions): Promise<Hash> {
-        try {
-            if (!this.superPaymasterAddress) {
-                throw new Error('SuperPaymaster address required for this client');
-            }
-            const sp = superPaymasterActions(this.superPaymasterAddress);
-            
-            return await sp(this.client).setProtocolFee({
-                newFeeBPS: bps,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-
-    async setTreasury(treasury: Address, options?: TransactionOptions): Promise<Hash> {
-        try {
-            if (!this.superPaymasterAddress) {
-                 throw new Error('SuperPaymaster address required for this client');
-            }
-            const sp = superPaymasterActions(this.superPaymasterAddress);
-            
-            return await sp(this.client).setTreasury({
-                treasury,
-                account: options?.account
-            });
-        } catch (error) {
-            throw error;
-        }
-    }
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './PaymasterOperatorClient.js';
-export * from './ProtocolClient.js';

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig.build.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "noEmit": false,
-    "declaration": true
-  },
-  "include": ["src/**/*"]
-}