@aastar/core 0.16.7

package/dist/actions/StateValidator.d.ts

@@ -0,0 +1,68 @@
+import { type Hex, type Address, type Chain } from 'viem';
+/**
+ * Interface definitions
+ */
+export interface ValidationParams {
+    rpcUrl: string;
+    chain: Chain;
+}
+export interface RoleValidationParams extends ValidationParams {
+    registryAddress: Address;
+    roleId: Hex;
+    userAddress: Address;
+}
+export interface BalanceValidationParams extends ValidationParams {
+    address: Address;
+    minBalance?: string;
+}
+export interface TokenBalanceValidationParams extends BalanceValidationParams {
+    tokenAddress: Address;
+}
+export interface DeploymentValidationParams extends ValidationParams {
+    contractAddress: Address;
+}
+export interface ValidationResult {
+    valid: boolean;
+    message?: string;
+    data?: any;
+}
+export interface AccountBalance {
+    address: Address;
+    eth: bigint;
+    gToken: bigint;
+    aPNTs: bigint;
+    xPNTs: bigint;
+}
+export declare class StateValidator {
+    /**
+     * Create PublicClient helper
+     */
+    private static createClient;
+    /**
+     * Batch fetch balances for multiple accounts
+     */
+    static getAccountBalances(params: {
+        rpcUrl: string;
+        chain: Chain;
+        addresses: Address[];
+        gTokenAddress?: Address;
+        aPNTsAddress?: Address;
+        xPNTsAddress?: Address;
+    }): Promise<AccountBalance[]>;
+    /**
+     * Role Validation
+     */
+    static validateRole(params: RoleValidationParams): Promise<ValidationResult>;
+    /**
+     * ETH Balance Validation
+     */
+    static validateETHBalance(params: BalanceValidationParams): Promise<ValidationResult>;
+    /**
+     * Token Balance Validation
+     */
+    static validateTokenBalance(params: TokenBalanceValidationParams): Promise<ValidationResult>;
+    /**
+     * Deployment Validation
+     */
+    static validateDeployment(params: DeploymentValidationParams): Promise<ValidationResult>;
+}

package/dist/actions/StateValidator.js

@@ -0,0 +1,187 @@
+import { createPublicClient, http, erc20Abi, formatEther } from 'viem';
+export class StateValidator {
+    /**
+     * Create PublicClient helper
+     */
+    static createClient(params) {
+        return createPublicClient({
+            chain: params.chain,
+            transport: http(params.rpcUrl)
+        });
+    }
+    /**
+     * Batch fetch balances for multiple accounts
+     */
+    static async getAccountBalances(params) {
+        const client = this.createClient({ rpcUrl: params.rpcUrl, chain: params.chain });
+        const results = await Promise.all(params.addresses.map(async (address) => {
+            const [eth, gToken, aPNTs, xPNTs] = await Promise.all([
+                client.getBalance({ address }),
+                params.gTokenAddress
+                    ? client.readContract({
+                        address: params.gTokenAddress,
+                        abi: erc20Abi,
+                        functionName: 'balanceOf',
+                        args: [address]
+                    })
+                    : Promise.resolve(0n),
+                params.aPNTsAddress
+                    ? client.readContract({
+                        address: params.aPNTsAddress,
+                        abi: erc20Abi,
+                        functionName: 'balanceOf',
+                        args: [address]
+                    })
+                    : Promise.resolve(0n),
+                params.xPNTsAddress
+                    ? client.readContract({
+                        address: params.xPNTsAddress,
+                        abi: erc20Abi,
+                        functionName: 'balanceOf',
+                        args: [address]
+                    })
+                    : Promise.resolve(0n)
+            ]);
+            return {
+                address,
+                eth,
+                gToken,
+                aPNTs,
+                xPNTs
+            };
+        }));
+        return results;
+    }
+    /**
+     * Role Validation
+     */
+    static async validateRole(params) {
+        try {
+            const client = this.createClient(params);
+            const hasRole = await client.readContract({
+                address: params.registryAddress,
+                abi: [{
+                        name: 'hasRole',
+                        type: 'function',
+                        stateMutability: 'view',
+                        inputs: [
+                            { name: 'roleId', type: 'bytes32' },
+                            { name: 'user', type: 'address' }
+                        ],
+                        outputs: [{ name: '', type: 'bool' }]
+                    }],
+                functionName: 'hasRole',
+                args: [params.roleId, params.userAddress]
+            });
+            return {
+                valid: hasRole,
+                message: hasRole
+                    ? `✅ User ${params.userAddress} has role ${params.roleId}`
+                    : `❌ User ${params.userAddress} does NOT have role ${params.roleId}`,
+                data: { hasRole }
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                message: `❌ Role validation failed: ${error.message}`,
+                data: { error }
+            };
+        }
+    }
+    /**
+     * ETH Balance Validation
+     */
+    static async validateETHBalance(params) {
+        try {
+            const client = this.createClient(params);
+            const balance = await client.getBalance({ address: params.address });
+            const balanceETH = Number(formatEther(balance));
+            if (params.minBalance) {
+                const minBalanceWei = BigInt(Math.floor(parseFloat(params.minBalance) * 1e18));
+                const sufficient = balance >= minBalanceWei;
+                return {
+                    valid: sufficient,
+                    message: sufficient
+                        ? `✅ ETH balance (${balanceETH.toFixed(4)}) meets minimum (${params.minBalance})`
+                        : `❌ ETH balance (${balanceETH.toFixed(4)}) below minimum (${params.minBalance})`,
+                    data: { balance, balanceETH, minBalance: params.minBalance }
+                };
+            }
+            return {
+                valid: true,
+                message: `ℹ️  ETH balance: ${balanceETH.toFixed(4)} ETH`,
+                data: { balance, balanceETH }
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                message: `❌ ETH balance validation failed: ${error.message}`,
+                data: { error }
+            };
+        }
+    }
+    /**
+     * Token Balance Validation
+     */
+    static async validateTokenBalance(params) {
+        try {
+            const client = this.createClient(params);
+            const balance = await client.readContract({
+                address: params.tokenAddress,
+                abi: erc20Abi,
+                functionName: 'balanceOf',
+                args: [params.address]
+            });
+            const balanceToken = Number(formatEther(balance));
+            if (params.minBalance) {
+                const minBalanceWei = BigInt(Math.floor(parseFloat(params.minBalance) * 1e18));
+                const sufficient = balance >= minBalanceWei;
+                return {
+                    valid: sufficient,
+                    message: sufficient
+                        ? `✅ Token balance (${balanceToken.toFixed(4)}) meets minimum (${params.minBalance})`
+                        : `❌ Token balance (${balanceToken.toFixed(4)}) below minimum (${params.minBalance})`,
+                    data: { balance, balanceToken, minBalance: params.minBalance }
+                };
+            }
+            return {
+                valid: true,
+                message: `ℹ️  Token balance: ${balanceToken.toFixed(4)}`,
+                data: { balance, balanceToken }
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                message: `❌ Token balance validation failed: ${error.message}`,
+                data: { error }
+            };
+        }
+    }
+    /**
+     * Deployment Validation
+     */
+    static async validateDeployment(params) {
+        try {
+            const client = this.createClient(params);
+            const code = await client.getBytecode({ address: params.contractAddress });
+            const isDeployed = code !== undefined && code !== '0x';
+            return {
+                valid: isDeployed,
+                message: isDeployed
+                    ? `✅ Contract deployed at ${params.contractAddress}`
+                    : `❌ No contract found at ${params.contractAddress}`,
+                data: { code, isDeployed }
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                message: `❌ Deployment validation failed: ${error.message}`,
+                data: { error }
+            };
+        }
+    }
+}

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

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

package/dist/actions/StateValidator.test.js

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { parseEther } from 'viem';
+import { StateValidator } from './StateValidator.js';
+import { sepolia } from 'viem/chains';
+// Mock viem
+vi.mock('viem', async () => {
+    const actual = await vi.importActual('viem');
+    return {
+        ...actual,
+        createPublicClient: vi.fn(),
+        http: vi.fn(),
+    };
+});
+import { createPublicClient } from 'viem';
+describe('StateValidator', () => {
+    let mockClient;
+    const MOCK_USER = '0x1234567890123456789012345678901234567890';
+    const MOCK_RPC = 'https://mock.rpc';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockClient = {
+            getBalance: vi.fn(),
+            readContract: vi.fn(),
+            getBytecode: vi.fn(),
+        };
+        createPublicClient.mockReturnValue(mockClient);
+    });
+    describe('getAccountBalances', () => {
+        it('should fetch balances for multiple accounts', async () => {
+            mockClient.getBalance.mockResolvedValue(parseEther('1.5'));
+            mockClient.readContract.mockResolvedValue(parseEther('1000'));
+            const balances = await StateValidator.getAccountBalances({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                addresses: [MOCK_USER],
+                gTokenAddress: '0xGTOKEN',
+                aPNTsAddress: '0xAPNTS',
+                xPNTsAddress: '0xXPNTS'
+            });
+            expect(balances).toHaveLength(1);
+            expect(balances[0].eth).toBe(parseEther('1.5'));
+            expect(balances[0].gToken).toBe(parseEther('1000'));
+            expect(mockClient.getBalance).toHaveBeenCalledWith({ address: MOCK_USER });
+        });
+    });
+    describe('validateRole', () => {
+        it('should return valid if user has role', async () => {
+            mockClient.readContract.mockResolvedValue(true);
+            const result = await StateValidator.validateRole({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                registryAddress: '0xREGISTRY',
+                roleId: '0xROLE',
+                userAddress: MOCK_USER
+            });
+            expect(result.valid).toBe(true);
+            expect(result.message).toContain('has role');
+        });
+        it('should return invalid if user does not have role', async () => {
+            mockClient.readContract.mockResolvedValue(false);
+            const result = await StateValidator.validateRole({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                registryAddress: '0xREGISTRY',
+                roleId: '0xROLE',
+                userAddress: MOCK_USER
+            });
+            expect(result.valid).toBe(false);
+            expect(result.message).toContain('does NOT have role');
+        });
+        it('should handle errors', async () => {
+            mockClient.readContract.mockRejectedValue(new Error('Contract error'));
+            const result = await StateValidator.validateRole({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                registryAddress: '0xREGISTRY',
+                roleId: '0xROLE',
+                userAddress: MOCK_USER
+            });
+            expect(result.valid).toBe(false);
+            expect(result.message).toContain('validation failed');
+        });
+    });
+    describe('validateETHBalance', () => {
+        it('should validate sufficient balance', async () => {
+            mockClient.getBalance.mockResolvedValue(parseEther('1.0'));
+            const result = await StateValidator.validateETHBalance({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                address: MOCK_USER,
+                minBalance: '0.5'
+            });
+            expect(result.valid).toBe(true);
+            expect(result.message).toContain('meets minimum');
+        });
+        it('should validate insufficient balance', async () => {
+            mockClient.getBalance.mockResolvedValue(parseEther('0.1'));
+            const result = await StateValidator.validateETHBalance({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                address: MOCK_USER,
+                minBalance: '0.5'
+            });
+            expect(result.valid).toBe(false);
+            expect(result.message).toContain('below minimum');
+        });
+    });
+    describe('validateTokenBalance', () => {
+        it('should validate token balance', async () => {
+            mockClient.readContract.mockResolvedValue(parseEther('100'));
+            const result = await StateValidator.validateTokenBalance({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                address: MOCK_USER,
+                tokenAddress: '0xTOKEN',
+                minBalance: '50'
+            });
+            expect(result.valid).toBe(true);
+            expect(result.message).toContain('meets minimum');
+        });
+    });
+    describe('validateDeployment', () => {
+        it('should return valid if contract is deployed', async () => {
+            mockClient.getBytecode.mockResolvedValue('0x1234');
+            const result = await StateValidator.validateDeployment({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                contractAddress: '0xCONTRACT'
+            });
+            expect(result.valid).toBe(true);
+            expect(result.message).toContain('deployed at');
+        });
+        it('should return invalid if contract is not deployed', async () => {
+            mockClient.getBytecode.mockResolvedValue('0x');
+            const result = await StateValidator.validateDeployment({
+                rpcUrl: MOCK_RPC,
+                chain: sepolia,
+                contractAddress: '0xCONTRACT'
+            });
+            expect(result.valid).toBe(false);
+            expect(result.message).toContain('No contract found');
+        });
+    });
+});

package/dist/actions/account.d.ts

@@ -0,0 +1,55 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type AccountActions = {
+    execute: (args: {
+        dest: Address;
+        value: bigint;
+        func: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeBatch: (args: {
+        dest: Address[];
+        value: bigint[];
+        func: Hex[];
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getNonce: () => Promise<bigint>;
+    entryPoint: () => Promise<Address>;
+    addDeposit: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawDepositTo: (args: {
+        withdrawAddress: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getDeposit: () => Promise<bigint>;
+    owner: () => Promise<Address>;
+    initialize: (args: {
+        owner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    upgradeToAndCall: (args: {
+        newImplementation: Address;
+        data: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    proxiableUUID: () => Promise<Hex>;
+    supportsInterface: (args: {
+        interfaceId: Hex;
+    }) => Promise<boolean>;
+    UPGRADE_INTERFACE_VERSION: () => Promise<string>;
+};
+export type AccountFactoryActions = {
+    createAccount: (args: {
+        owner: Address;
+        salt: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getAddress: (args: {
+        owner: Address;
+        salt: bigint;
+    }) => Promise<Address>;
+    accountImplementation: () => Promise<Address>;
+};
+export declare const accountActions: (address: Address) => (client: PublicClient | WalletClient) => AccountActions;
+export declare const accountFactoryActions: (address: Address) => (client: PublicClient | WalletClient) => AccountFactoryActions;

package/dist/actions/account.js

@@ -0,0 +1,133 @@
+import { SimpleAccountABI, SimpleAccountFactoryABI } from '../abis/index.js';
+export const accountActions = (address) => (client) => ({
+    async execute({ dest, value, func, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'execute',
+            args: [dest, value, func],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async executeBatch({ dest, value, func, account }) {
+        // Zip arguments into Call[] struct format
+        const calls = dest.map((t, i) => ({
+            target: t,
+            value: value[i],
+            data: func[i]
+        }));
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'executeBatch',
+            args: [calls],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getNonce() {
+        return client.readContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'getNonce',
+            args: []
+        });
+    },
+    async entryPoint() {
+        return client.readContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'entryPoint',
+            args: []
+        });
+    },
+    async addDeposit({ account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'addDeposit',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async withdrawDepositTo({ withdrawAddress, amount, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'withdrawDepositTo',
+            args: [withdrawAddress, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getDeposit() {
+        return client.readContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'getDeposit',
+            args: []
+        });
+    },
+    async owner() {
+        return client.readContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async initialize({ owner, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'initialize',
+            args: [owner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async upgradeToAndCall({ newImplementation, data, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'upgradeToAndCall',
+            args: [newImplementation, data],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async proxiableUUID() {
+        return client.readContract({ address, abi: SimpleAccountABI, functionName: 'proxiableUUID', args: [] });
+    },
+    async supportsInterface({ interfaceId }) {
+        return client.readContract({ address, abi: SimpleAccountABI, functionName: 'supportsInterface', args: [interfaceId] });
+    },
+    async UPGRADE_INTERFACE_VERSION() {
+        return client.readContract({ address, abi: SimpleAccountABI, functionName: 'UPGRADE_INTERFACE_VERSION', args: [] });
+    }
+});
+export const accountFactoryActions = (address) => (client) => ({
+    async createAccount({ owner, salt, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountFactoryABI,
+            functionName: 'createAccount',
+            args: [owner, salt],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getAddress({ owner, salt }) {
+        return client.readContract({
+            address,
+            abi: SimpleAccountFactoryABI,
+            functionName: 'getAddress',
+            args: [owner, salt]
+        });
+    },
+    async accountImplementation() {
+        return client.readContract({ address, abi: SimpleAccountFactoryABI, functionName: 'accountImplementation', args: [] });
+    }
+});

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

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