@aastar/dapp 0.16.7

package/dist/core/src/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/core/src/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/core/src/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/core/src/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/core/src/actions/aggregator.d.ts

@@ -0,0 +1,17 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type AggregatorActions = {
+    registerBLSPublicKey: (args: {
+        address: Address;
+        publicKey: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setBLSThreshold: (args: {
+        address: Address;
+        threshold: number;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getBLSThreshold: (args: {
+        address: Address;
+    }) => Promise<bigint>;
+};
+export declare const aggregatorActions: () => (client: PublicClient | WalletClient) => AggregatorActions;

package/dist/core/src/actions/aggregator.js

@@ -0,0 +1,31 @@
+import { BLSAggregatorABI } from '../abis/index.js';
+export const aggregatorActions = () => (client) => ({
+    async registerBLSPublicKey({ address, publicKey, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'registerBLSPublicKey',
+            args: [publicKey],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setBLSThreshold({ address, threshold, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'setThreshold',
+            args: [BigInt(threshold)],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getBLSThreshold({ address }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'threshold',
+            args: []
+        });
+    }
+});

package/dist/core/src/actions/dvt.d.ts

@@ -0,0 +1,30 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type DVTActions = {
+    createSlashProposal: (args: {
+        address: Address;
+        operator: Address;
+        level: number;
+        reason: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    signSlashProposal: (args: {
+        address: Address;
+        proposalId: bigint;
+        signature: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeSlashWithProof: (args: {
+        address: Address;
+        proposalId: bigint;
+        repUsers: Address[];
+        newScores: bigint[];
+        epoch: bigint;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    isValidator: (args: {
+        address: Address;
+        user: Address;
+    }) => Promise<boolean>;
+};
+export declare const dvtActions: () => (client: PublicClient | WalletClient) => DVTActions;

package/dist/core/src/actions/dvt.js

@@ -0,0 +1,41 @@
+import { DVTValidatorABI } from '../abis/index.js';
+export const dvtActions = () => (client) => ({
+    async createSlashProposal({ address, operator, level, reason, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'createProposal',
+            args: [operator, level, reason],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async signSlashProposal({ address, proposalId, signature, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'signProposal',
+            args: [proposalId, signature],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async executeSlashWithProof({ address, proposalId, repUsers, newScores, epoch, proof, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'executeWithProof',
+            args: [proposalId, repUsers, newScores, epoch, proof],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async isValidator({ address, user }) {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'isValidator',
+            args: [user]
+        });
+    }
+});

package/dist/core/src/actions/entryPoint.d.ts

@@ -0,0 +1,90 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export declare enum EntryPointVersion {
+    V06 = "0.6",
+    V07 = "0.7"
+}
+export type EntryPointActions = {
+    balanceOf: (args: {
+        account: Address;
+    }) => Promise<bigint>;
+    depositTo: (args: {
+        account: Address;
+        amount: bigint;
+        txAccount?: Account | Address;
+    }) => Promise<Hash>;
+    getNonce: (args: {
+        sender: Address;
+        key: bigint;
+    }) => Promise<bigint>;
+    getDepositInfo: (args: {
+        account: Address;
+    }) => Promise<{
+        deposit: bigint;
+        staked: boolean;
+        stake: bigint;
+        unstakeDelaySec: number;
+        withdrawTime: number;
+    }>;
+    addStake: (args: {
+        unstakeDelaySec: number;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    unlockStake: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawStake: (args: {
+        withdrawAddress: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawTo: (args: {
+        withdrawAddress: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    handleOps: (args: {
+        ops: any[];
+        beneficiary: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    handleAggregatedOps: (args: {
+        opsPerAggregator: any[];
+        beneficiary: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    innerHandleOp: (args: {
+        callData: Hex;
+        opInfo: any;
+        context: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    delegateAndRevert: (args: {
+        target: Address;
+        data: Hex;
+        account?: Account | Address;
+    }) => Promise<void>;
+    getUserOpHash: (args: {
+        op: any;
+    }) => Promise<Hash>;
+    getSenderAddress: (args: {
+        initCode: Hex;
+    }) => Promise<Address>;
+    senderCreator: () => Promise<Address>;
+    incrementNonce: (args: {
+        key: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    nonceSequenceNumber: (args: {
+        sender: Address;
+        key: bigint;
+    }) => Promise<bigint>;
+    supportsInterface: (args: {
+        interfaceId: Hex;
+    }) => Promise<boolean>;
+    eip712Domain: () => Promise<any>;
+    getCurrentUserOpHash: () => Promise<Hash>;
+    getDomainSeparatorV4: () => Promise<Hex>;
+    getPackedUserOpTypeHash: () => Promise<Hex>;
+    version: EntryPointVersion;
+};
+export declare const entryPointActions: (address: Address, version?: EntryPointVersion) => (client: PublicClient | WalletClient) => EntryPointActions;