@aastar/core 0.16.7

package/dist/actions/factory.js

@@ -0,0 +1,442 @@
+import { parseEther } from 'viem';
+import { xPNTsFactoryABI, PaymasterFactoryABI } from '../abis/index.js';
+export const xPNTsFactoryActions = (address) => (client) => ({
+    async createToken({ name, symbol, community, account }) {
+        // Map to deployxPNTsToken
+        // Args: name, symbol, communityName, communityENS, exchangeRate, paymasterAOA
+        // We use name/symbol as community name/ens placeholder if not provided
+        // We assume msg.sender (account) is the community owner
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'deployxPNTsToken',
+            args: [
+                name,
+                symbol,
+                name, // communityName
+                symbol, // communityENS
+                parseEther('1'), // exchangeRate: 1:1 with 18 decimals (1e18)
+                '0x0000000000000000000000000000000000000000' // paymasterAOA
+            ],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async deployForCommunity({ community, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'deployForCommunity',
+            args: [community],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getTokenAddress({ community }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getTokenAddress',
+            args: [community]
+        });
+    },
+    async predictAddress({ community, salt }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'predictAddress',
+            args: salt !== undefined ? [community, salt] : [community]
+        });
+    },
+    async isTokenDeployed({ community }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'isTokenDeployed',
+            args: [community]
+        });
+    },
+    async getCommunityByToken({ token }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getCommunityByToken',
+            args: [token]
+        });
+    },
+    async getAllTokens() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getAllTokens',
+            args: []
+        });
+    },
+    async getTokenCount() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getTokenCount',
+            args: []
+        });
+    },
+    async deployedTokens({ index }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'deployedTokens',
+            args: [index]
+        });
+    },
+    async communityToToken({ community }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'communityToToken',
+            args: [community]
+        });
+    },
+    async setRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setSuperPaymaster({ paymaster, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'setSuperPaymaster',
+            args: [paymaster],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setImplementation({ impl, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'setImplementation',
+            args: [impl],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getImplementation() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getImplementation',
+            args: []
+        });
+    },
+    async REGISTRY() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    async tokenImplementation() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'tokenImplementation',
+            args: []
+        });
+    },
+    async xPNTsFactoryOwner() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async transferXPNTsFactoryOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async renounceXPNTsFactoryOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async deployxPNTsToken(args) {
+        return this.createToken(args);
+    },
+    // Prediction & Economics
+    async predictDepositAmount({ community, userCount }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'predictDepositAmount', args: [community, userCount] });
+    },
+    async getPredictionParams({ community }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'getPredictionParams', args: [community] });
+    },
+    async getDepositBreakdown({ community }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'getDepositBreakdown', args: [community] });
+    },
+    async getAPNTsPrice() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'getAPNTsPrice', args: [] });
+    },
+    async aPNTsPriceUSD() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'aPNTsPriceUSD', args: [] });
+    },
+    async SUPER_PAYMASTER() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'SUPER_PAYMASTER', args: [] });
+    },
+    async SUPERPAYMASTER() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'SUPERPAYMASTER', args: [] });
+    },
+    // Admin & Config
+    async setIndustryMultiplier({ industry, multiplier, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'setIndustryMultiplier', args: [industry, multiplier], account: account, chain: client.chain });
+    },
+    async setSuperPaymasterAddress({ paymaster, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'setSuperPaymasterAddress', args: [paymaster], account: account, chain: client.chain });
+    },
+    async updateAPNTsPrice({ newPrice, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'updateAPNTsPrice', args: [newPrice], account: account, chain: client.chain });
+    },
+    async updatePrediction({ community, userCount, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'updatePrediction', args: [community, userCount], account: account, chain: client.chain });
+    },
+    async updatePredictionCustom({ community, params, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'updatePredictionCustom', args: [community, params], account: account, chain: client.chain });
+    },
+    // Views
+    async hasToken({ token }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'hasToken', args: [token] });
+    },
+    async getDeployedCount() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'getDeployedCount', args: [] });
+    },
+    async industryMultipliers({ industry }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'industryMultipliers', args: [industry] });
+    },
+    async getIndustryMultiplier({ industry }) {
+        return this.industryMultipliers({ industry });
+    },
+    async predictions({ community }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'predictions', args: [community] });
+    },
+    // Constants
+    async DEFAULT_SAFETY_FACTOR() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'DEFAULT_SAFETY_FACTOR', args: [] });
+    },
+    async MIN_SUGGESTED_AMOUNT() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'MIN_SUGGESTED_AMOUNT', args: [] });
+    },
+    async xPNTsFactoryVersion() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});
+export const paymasterFactoryActions = (address) => (client) => ({
+    async deployPaymaster({ owner, version, initData, account }) {
+        // Factory.deployPaymaster(version, initData)
+        const defaultVer = 'v4.2'; // 当前标准版本
+        const useVer = version || defaultVer;
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'deployPaymaster',
+            args: [useVer, initData || '0x'],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async deployPaymasterDeterministic({ owner, version, initData, salt, account }) {
+        return client.writeContract({ address, abi: PaymasterFactoryABI, functionName: 'deployPaymasterDeterministic', args: [version || 'v4.2', initData || '0x', salt], account: account, chain: client.chain });
+    },
+    async predictPaymasterAddress({ owner, salt }) {
+        // Note: Contract might not have this function exposed directly or it is separate logic
+        // But ABI says it's missing, so let's try calling it if it exists in ABI
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'predictPaymasterAddress', args: [owner, salt] });
+    },
+    async calculateAddress({ owner }) {
+        // This function doesn't exist in V4 factory for non-deterministic deploy
+        // We throw to avoid misleading usage
+        throw new Error('Predicting address not supported for standard deploy. Use getPaymaster after deploy.');
+    },
+    async getPaymaster({ owner }) {
+        // 使用 paymasterByOperator mapping（不支持 salt）
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'paymasterByOperator',
+            args: [owner]
+        });
+    },
+    async getPaymasterCount() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'getPaymasterCount',
+            args: []
+        });
+    },
+    async getAllPaymasters() {
+        // Not directly supported by contract as single call (it has list + pagination), using pagination shim
+        const count = await client.readContract({
+            address, abi: PaymasterFactoryABI, functionName: 'getPaymasterCount', args: []
+        });
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'getPaymasterList',
+            args: [0n, count]
+        });
+    },
+    async isPaymasterDeployed({ owner }) {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'hasPaymaster', // Corrected from isPaymasterDeployed
+            args: [owner]
+        });
+    },
+    async hasPaymaster({ owner }) { return this.isPaymasterDeployed({ owner }); },
+    async getPaymasterList({ offset, limit }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'getPaymasterList', args: [offset, limit] });
+    },
+    async paymasterList({ index }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'paymasterList', args: [index] });
+    },
+    async totalDeployed() {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'totalDeployed', args: [] });
+    },
+    async getOperatorByPaymaster({ paymaster }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'getOperatorByPaymaster', args: [paymaster] });
+    },
+    async operatorByPaymaster({ paymaster }) { return this.getOperatorByPaymaster({ paymaster }); },
+    async getPaymasterByOperator({ operator }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'getPaymasterByOperator', args: [operator] });
+    },
+    async paymasterByOperator({ operator }) { return this.getPaymasterByOperator({ operator }); },
+    async getPaymasterInfo({ paymaster }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'getPaymasterInfo', args: [paymaster] });
+    },
+    async hasImplementation({ version }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'hasImplementation', args: [version] });
+    },
+    async implementations({ version }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'implementations', args: [version] });
+    },
+    async setImplementationV4({ impl, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'setImplementationV4',
+            args: [impl],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getImplementationV4() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'getImplementationV4',
+            args: []
+        });
+    },
+    async setRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async addImplementation({ version, implementation, account }) {
+        return client.writeContract({ address, abi: PaymasterFactoryABI, functionName: 'addImplementation', args: [version, implementation], account: account, chain: client.chain });
+    },
+    async upgradeImplementation({ version, newImplementation, account }) {
+        return client.writeContract({ address, abi: PaymasterFactoryABI, functionName: 'upgradeImplementation', args: [version, newImplementation], account: account, chain: client.chain });
+    },
+    async setDefaultVersion({ version, account }) {
+        return client.writeContract({ address, abi: PaymasterFactoryABI, functionName: 'setDefaultVersion', args: [version], account: account, chain: client.chain });
+    },
+    async REGISTRY() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    async ENTRY_POINT() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'ENTRY_POINT',
+            args: []
+        });
+    },
+    async paymasterFactoryOwner() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async transferPaymasterFactoryOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async renouncePaymasterFactoryOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async defaultVersion() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'defaultVersion',
+            args: []
+        });
+    },
+    async paymasterFactoryVersion() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});

package/dist/actions/factory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/factory.test.js

@@ -0,0 +1,197 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { xPNTsFactoryActions, paymasterFactoryActions } from './factory.js';
+describe('Factory Actions', () => {
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_FACTORY = '0x1111111111111111111111111111111111111111';
+    const MOCK_COMMUNITY = '0x2222222222222222222222222222222222222222';
+    const MOCK_USER = '0x3333333333333333333333333333333333333333';
+    beforeEach(() => {
+        mockAccount = {
+            address: MOCK_USER,
+            type: 'json-rpc'
+        };
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+    describe('xPNTsFactoryActions', () => {
+        it('should create token', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockWalletClient);
+            const result = await actions.createToken({
+                name: 'Test',
+                symbol: 'TST',
+                community: MOCK_COMMUNITY,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'deployxPNTsToken',
+            }));
+        });
+        it('should get token address', async () => {
+            const mockToken = '0xTOKEN';
+            mockPublicClient.readContract.mockResolvedValue(mockToken);
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            const result = await actions.getTokenAddress({ community: MOCK_COMMUNITY });
+            expect(result).toBe(mockToken);
+        });
+        it('should predict address', async () => {
+            const mockToken = '0xPREDICTED';
+            mockPublicClient.readContract.mockResolvedValue(mockToken);
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            const result = await actions.predictAddress({ community: MOCK_COMMUNITY, salt: 1234n });
+            expect(result).toBe(mockToken);
+        });
+        it('should check if token is deployed', async () => {
+            mockPublicClient.readContract.mockResolvedValue(true);
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            const result = await actions.isTokenDeployed({ community: MOCK_COMMUNITY });
+            expect(result).toBe(true);
+        });
+        it('should handle predictions and economics', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(100n) // predictDepositAmount
+                .mockResolvedValueOnce([1n, 2n, 3n]) // getPredictionParams
+                .mockResolvedValueOnce(50n); // getAPNTsPrice
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            expect(await actions.predictDepositAmount({ community: MOCK_COMMUNITY, userCount: 10n })).toBe(100n);
+            expect(await actions.getPredictionParams({ community: MOCK_COMMUNITY })).toEqual([1n, 2n, 3n]);
+            expect(await actions.getAPNTsPrice()).toBe(50n);
+        });
+        it('should manage configuration', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockWalletClient);
+            expect(await actions.setIndustryMultiplier({ industry: 'tech', multiplier: 2n, account: mockAccount })).toBe(txHash);
+            expect(await actions.setSuperPaymasterAddress({ paymaster: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.updateAPNTsPrice({ newPrice: 100n, account: mockAccount })).toBe(txHash);
+        });
+        it('should view config', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(123n) // industryMultipliers
+                .mockResolvedValueOnce(MOCK_USER); // SUPER_PAYMASTER
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            expect(await actions.industryMultipliers({ industry: 'tech' })).toBe(123n);
+            expect(await actions.SUPER_PAYMASTER()).toBe(MOCK_USER);
+        });
+    });
+    describe('paymasterFactoryActions', () => {
+        it('should deploy for community', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockWalletClient);
+            const result = await actions.deployForCommunity({ community: MOCK_COMMUNITY, account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should query tokens and stats', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(MOCK_COMMUNITY) // getCommunityByToken
+                .mockResolvedValueOnce(['0xT1']) // getAllTokens
+                .mockResolvedValueOnce(1n) // getTokenCount
+                .mockResolvedValueOnce('0xT1'); // deployedTokens
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            expect(await actions.getCommunityByToken({ token: '0xT' })).toBe(MOCK_COMMUNITY);
+            expect(await actions.getAllTokens()).toEqual(['0xT1']);
+            expect(await actions.getTokenCount()).toBe(1n);
+            expect(await actions.deployedTokens({ index: 0n })).toBe('0xT1');
+        });
+        it('should manage implementation and configuration', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            mockPublicClient.readContract.mockResolvedValue(MOCK_USER);
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockWalletClient);
+            expect(await actions.setImplementation({ impl: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.setRegistry({ registry: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.setSuperPaymaster({ paymaster: MOCK_USER, account: mockAccount })).toBe(txHash);
+            const pClient = xPNTsFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            expect(await pClient.getImplementation()).toBe(MOCK_USER);
+            expect(await pClient.REGISTRY()).toBe(MOCK_USER);
+            expect(await pClient.SUPER_PAYMASTER()).toBe(MOCK_USER);
+        });
+        it('should handle ownership and version', async () => {
+            mockPublicClient.readContract.mockResolvedValue(MOCK_USER);
+            const actions = xPNTsFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            expect(await actions.xPNTsFactoryOwner()).toBe(MOCK_USER);
+            mockPublicClient.readContract.mockResolvedValue('v1');
+            expect(await actions.xPNTsFactoryVersion()).toBe('v1');
+        });
+    });
+    describe('paymasterFactoryActions', () => {
+        it('should deploy paymaster', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterFactoryActions(MOCK_FACTORY)(mockWalletClient);
+            const result = await actions.deployPaymaster({
+                owner: MOCK_USER,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should get paymaster by operator', async () => {
+            const mockPM = '0xPAYMASTER';
+            mockPublicClient.readContract.mockResolvedValue(mockPM);
+            const actions = paymasterFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            const result = await actions.getPaymaster({ owner: MOCK_USER });
+            expect(result).toBe(mockPM);
+        });
+        it('should get all paymasters', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(2n) // count
+                .mockResolvedValueOnce(['0xPM1', '0xPM2']); // list
+            const actions = paymasterFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            const result = await actions.getAllPaymasters();
+            expect(result).toEqual(['0xPM1', '0xPM2']);
+        });
+        it('should manage implementation and registry', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            mockPublicClient.readContract.mockResolvedValue(MOCK_USER);
+            const actions = paymasterFactoryActions(MOCK_FACTORY)(mockWalletClient);
+            expect(await actions.setImplementationV4({ impl: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.setRegistry({ registry: MOCK_USER, account: mockAccount })).toBe(txHash);
+            const pClient = paymasterFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            expect(await pClient.getImplementationV4()).toBe(MOCK_USER);
+            expect(await pClient.REGISTRY()).toBe(MOCK_USER);
+            expect(await pClient.ENTRY_POINT()).toBe(MOCK_USER);
+        });
+        it('should check if paymaster is deployed', async () => {
+            mockPublicClient.readContract.mockResolvedValue(true);
+            const actions = paymasterFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            const result = await actions.isPaymasterDeployed({ owner: MOCK_USER });
+            expect(result).toBe(true);
+        });
+        it('should get versions and ownership', async () => {
+            mockPublicClient.readContract.mockResolvedValue('v1');
+            const actions = paymasterFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            expect(await actions.paymasterFactoryVersion()).toBe('v1');
+            expect(await actions.defaultVersion()).toBe('v1');
+            mockPublicClient.readContract.mockResolvedValue(MOCK_USER);
+            expect(await actions.paymasterFactoryOwner()).toBe(MOCK_USER);
+        });
+        it('should handle implementations list', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(true) // implementations
+                .mockResolvedValueOnce(['0xI1']) // getPaymasterList
+                .mockResolvedValueOnce(5n); // totalDeployed
+            const actions = paymasterFactoryActions(MOCK_FACTORY)(mockPublicClient);
+            expect(await actions.implementations({ version: 'v1' })).toBe(true);
+            expect(await actions.getPaymasterList({ offset: 0n, limit: 10n })).toEqual(['0xI1']);
+            expect(await actions.totalDeployed()).toBe(5n);
+        });
+        it('should manage implementations', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterFactoryActions(MOCK_FACTORY)(mockWalletClient);
+            expect(await actions.addImplementation({ version: 'v2', implementation: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.setDefaultVersion({ version: 'v2', account: mockAccount })).toBe(txHash);
+        });
+    });
+});

package/dist/actions/faucet.d.ts

@@ -0,0 +1,48 @@
+import { type Address, type WalletClient, type PublicClient } from 'viem';
+export declare class SepoliaFaucetAPI {
+    /**
+     * Orchestrates the complete setup for a test account.
+     * 1. Funds ETH
+     * 2. Registers ENDUSER role
+     * 3. Mints potential Paymaster Tokens (cPNTs/dPNTs)
+     * 4. Deposits to Paymaster V4 (if address provided) using Admin's tokens
+     */
+    static prepareTestAccount(adminWallet: WalletClient, publicClient: PublicClient, config: {
+        targetAA: Address;
+        token: Address;
+        registry: Address;
+        paymasterV4?: Address;
+        superPaymaster?: Address;
+        ethAmount?: bigint;
+        tokenAmount?: bigint;
+        community?: Address;
+    }): Promise<{
+        ethFunded: boolean;
+        roleRegistered: boolean;
+        tokenMinted: boolean;
+        paymasterDeposited: boolean;
+    }>;
+    /**
+     * Funds the target with ETH if balance is below threshold.
+     */
+    static fundETH(adminWallet: WalletClient, publicClient: PublicClient, target: Address, amount: bigint): Promise<boolean>;
+    /**
+     * Registers the ENDUSER role via Registry.
+     */
+    /**
+     * Registers the ENDUSER role using Sponsor Mode (Admin pays stake).
+     */
+    static registerEndUser(adminWallet: WalletClient, publicClient: PublicClient, registryAddr: Address, target: Address, gasToken: Address, // Re-using the 'token' passed in config which is GToken
+    community?: Address): Promise<boolean>;
+    /**
+     * Mints tokens directly to the target.
+     */
+    static mintTestTokens(adminWallet: WalletClient, publicClient: PublicClient, token: Address, target: Address, amount: bigint): Promise<boolean>;
+    /**
+     * Complex Flow:
+     * 1. Admin mints tokens to SELF.
+     * 2. Admin approves Paymaster.
+     * 3. Admin calls depositFor(target) on Paymaster.
+     */
+    static adminDepositForUser(adminWallet: WalletClient, publicClient: PublicClient, paymaster: Address, target: Address, token: Address, amount: bigint): Promise<boolean>;
+}