@aastar/core 0.16.7 → 0.16.11

package/dist/actions/superPaymaster.js

@@ -1,644 +1,978 @@
 import { SuperPaymasterABI } from '../abis/index.js';
+import { validateAddress, validateRequired, validateAmount } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
 export const superPaymasterActions = (address) => (client) => ({
     // Deposit & Withdrawal
-    async superPaymasterDeposit({ amount, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'deposit',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Semantic alias: depositAPNTs - uses aPNTs token (nonpayable)
-    async superPaymasterDepositAPNTs({ amount, account }) {
-        return this.superPaymasterDeposit({ amount, account });
-    },
-    // depositETH - uses native ETH (payable, no args)
-    async superPaymasterDepositETH({ value, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'deposit',
-            args: [],
-            value,
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterWithdraw({ amount, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'withdraw',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterDepositFor({ operator, amount, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'depositFor',
-            args: [operator, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterWithdrawTo({ to, amount, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'withdrawTo',
-            args: [to, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterAddSuperStake({ amount, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'addStake',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterUnlockSuperStake({ account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'unlockStake',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterWithdrawStake({ to, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'withdrawStake',
-            args: [to],
-            account: account,
-            chain: client.chain
-        });
+    async deposit({ amount, account }) {
+        try {
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'deposit',
+                args: [amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'deposit');
+        }
+    },
+    async depositETH({ value, account }) {
+        try {
+            validateAmount(value, 'value');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'deposit',
+                args: [],
+                value,
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'depositETH');
+        }
+    },
+    async depositFor({ targetOperator, amount, account }) {
+        try {
+            validateAddress(targetOperator, 'targetOperator');
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'depositFor',
+                args: [targetOperator, amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'depositFor');
+        }
+    },
+    async withdrawTo({ to, amount, account }) {
+        try {
+            validateAddress(to, 'to');
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'withdrawTo',
+                args: [to, amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'withdrawTo');
+        }
+    },
+    async withdraw({ amount, account }) {
+        try {
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'withdraw',
+                args: [amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'withdraw');
+        }
+    },
+    // Staking
+    async addStake({ unstakeDelaySec, value, account }) {
+        try {
+            validateRequired(unstakeDelaySec, 'unstakeDelaySec');
+            validateAmount(value, 'value');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'addStake',
+                args: [unstakeDelaySec],
+                value,
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'addStake');
+        }
+    },
+    async unlockStake({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'unlockStake',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'unlockStake');
+        }
+    },
+    async withdrawStake({ to, account }) {
+        try {
+            validateAddress(to, 'to');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'withdrawStake',
+                args: [to],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'withdrawStake');
+        }
     },
     // Operator Management
-    async superPaymasterConfigureOperator({ xPNTsToken, treasury, exchangeRate, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'configureOperator',
-            args: [xPNTsToken, treasury, exchangeRate],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterSetOperatorPaused({ operator, paused, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setOperatorPaused',
-            args: [operator, paused],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterUpdateReputation({ operator, newReputation, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'updateReputation',
-            args: [operator, newReputation],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterExecuteSlashWithBLS({ operator, roleId, amount, reason, blsSignature, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'executeSlashWithBLS',
-            args: [operator, roleId, amount, reason, blsSignature],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Price & Configuration
-    async superPaymasterSetAPNTsPrice({ priceUSD, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setAPNTsPrice',
-            args: [priceUSD],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterSetCachedPrice({ price, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setCachedPrice',
-            args: [price],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterSetProtocolFee({ feeRecipient, feeBps, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setProtocolFee',
-            args: [feeRecipient, feeBps],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // User Management
-    async superPaymasterBlockUser({ user, blocked, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'blockUser',
-            args: [user, blocked],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Validation (EntryPoint calls)
-    async superPaymasterValidatePaymasterUserOp({ userOp, userOpHash, maxCost }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'validatePaymasterUserOp',
-            args: [userOp, userOpHash, maxCost]
-        });
-    },
-    async superPaymasterPostOp({ mode, context, actualGasCost, actualUserOpFeePerGas }) {
-        // postOp is called by EntryPoint, typically not called directly
-        throw new Error('postOp is called by EntryPoint after UserOp execution');
+    async configureOperator({ xPNTsToken, opTreasury, exchangeRate, account }) {
+        try {
+            validateAddress(xPNTsToken, 'xPNTsToken');
+            validateAddress(opTreasury, 'opTreasury');
+            validateAmount(exchangeRate, 'exchangeRate');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'configureOperator',
+                args: [xPNTsToken, opTreasury, exchangeRate],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'configureOperator');
+        }
+    },
+    async setOperatorPaused({ operator, paused, account }) {
+        try {
+            validateAddress(operator, 'operator');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'setOperatorPaused',
+                args: [operator, paused],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setOperatorPaused');
+        }
+    },
+    async setOperatorLimits({ minTxInterval, account }) {
+        try {
+            validateRequired(minTxInterval, 'minTxInterval');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'setOperatorLimits',
+                args: [minTxInterval],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setOperatorLimits');
+        }
+    },
+    async updateReputation({ operator, newScore, account }) {
+        try {
+            validateAddress(operator, 'operator');
+            validateAmount(newScore, 'newScore');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'updateReputation',
+                args: [operator, newScore],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'updateReputation');
+        }
+    },
+    async executeSlashWithBLS({ operator, level, proof, account }) {
+        try {
+            validateAddress(operator, 'operator');
+            validateRequired(level, 'level');
+            validateRequired(proof, 'proof');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'executeSlashWithBLS',
+                args: [operator, level, proof],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'executeSlashWithBLS');
+        }
+    },
+    async slashOperator({ operator, level, penaltyAmount, reason, account }) {
+        try {
+            validateAddress(operator, 'operator');
+            validateRequired(level, 'level');
+            validateAmount(penaltyAmount, 'penaltyAmount');
+            validateRequired(reason, 'reason');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'slashOperator',
+                args: [operator, level, penaltyAmount, reason],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'slashOperator');
+        }
+    },
+    // User & SBT
+    async updateBlockedStatus({ operator, users, statuses, account }) {
+        try {
+            validateAddress(operator, 'operator');
+            validateRequired(users, 'users');
+            validateRequired(statuses, 'statuses');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'updateBlockedStatus',
+                args: [operator, users, statuses],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'updateBlockedStatus');
+        }
+    },
+    async updateSBTStatus({ user, status, account }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'updateSBTStatus',
+                args: [user, status],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'updateSBTStatus');
+        }
+    },
+    // Price
+    async setAPNTSPrice({ newPrice, account }) {
+        try {
+            validateAmount(newPrice, 'newPrice');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'setAPNTSPrice',
+                args: [newPrice],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setAPNTSPrice');
+        }
+    },
+    async updatePrice({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'updatePrice',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'updatePrice');
+        }
+    },
+    async updatePriceDVT({ price, updatedAt, proof, account }) {
+        try {
+            validateRequired(price, 'price');
+            validateRequired(updatedAt, 'updatedAt');
+            validateRequired(proof, 'proof');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'updatePriceDVT',
+                args: [price, updatedAt, proof],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'updatePriceDVT');
+        }
+    },
+    // Fees & Admin
+    async setProtocolFee({ newFeeBPS, account }) {
+        try {
+            validateAmount(newFeeBPS, 'newFeeBPS');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'setProtocolFee',
+                args: [newFeeBPS],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setProtocolFee');
+        }
+    },
+    async setTreasury({ treasury, account }) {
+        try {
+            validateAddress(treasury, 'treasury');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'setTreasury',
+                args: [treasury],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setTreasury');
+        }
+    },
+    async setXPNTsFactory({ factory, account }) {
+        try {
+            validateAddress(factory, 'factory');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'setXPNTsFactory',
+                args: [factory],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setXPNTsFactory');
+        }
+    },
+    async setAPNTsToken({ token, account }) {
+        try {
+            validateAddress(token, 'token');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'setAPNTsToken',
+                args: [token],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setAPNTsToken');
+        }
+    },
+    async setBLSAggregator({ aggregator, account }) {
+        try {
+            validateAddress(aggregator, 'aggregator');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'setBLSAggregator',
+                args: [aggregator],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setBLSAggregator');
+        }
+    },
+    async withdrawProtocolRevenue({ to, amount, account }) {
+        try {
+            validateAddress(to, 'to');
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'withdrawProtocolRevenue',
+                args: [to, amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'withdrawProtocolRevenue');
+        }
+    },
+    // Callbacks & Validation
+    async onTransferReceived({ operator, from, value, data }) {
+        try {
+            validateAddress(operator, 'operator');
+            validateAddress(from, 'from');
+            validateAmount(value, 'value');
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'onTransferReceived',
+                args: [operator, from, value, data]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'onTransferReceived');
+        }
+    },
+    async validatePaymasterUserOp({ userOp, userOpHash, maxCost }) {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'validatePaymasterUserOp',
+                args: [userOp, userOpHash, maxCost]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'validatePaymasterUserOp');
+        }
     },
     // View Functions
-    async superPaymasterOperators({ operator }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'operators',
-            args: [operator]
-        });
-    },
-    async superPaymasterGetDeposit() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'getDeposit',
-            args: []
-        });
-    },
-    async superPaymasterGetAvailableCredit({ operator, user }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'getAvailableCredit',
-            args: [operator, user]
-        });
-    },
-    async superPaymasterBlockedUsers({ user }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'blockedUsers',
-            args: [user]
-        });
-    },
-    // Convenience function: Get operator's aPNTs balance
-    async superPaymasterBalanceOfOperator({ operator }) {
-        const operatorConfig = await this.superPaymasterOperators({ operator });
-        return operatorConfig[0]; // aPNTsBalance is the first field
-    },
-    async superPaymasterAPNTsPriceUSD() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'aPNTsPriceUSD',
-            args: []
-        });
-    },
-    async superPaymasterCachedPrice() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'cachedPrice',
-            args: []
-        });
-    },
-    async superPaymasterProtocolFee() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'protocolFee',
-            args: []
-        });
-    },
-    async superPaymasterEntryPoint() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'entryPoint',
-            args: []
-        });
+    async operators({ operator }) {
+        try {
+            validateAddress(operator, 'operator');
+            const result = await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'operators',
+                args: [operator]
+            });
+            if (Array.isArray(result)) {
+                return {
+                    aPNTsBalance: result[0],
+                    exchangeRate: result[1],
+                    isConfigured: result[2],
+                    isPaused: result[3],
+                    xPNTsToken: result[4],
+                    reputation: result[5],
+                    minTxInterval: result[6],
+                    treasury: result[7],
+                    totalSpent: result[8],
+                    totalTxSponsored: result[9]
+                };
+            }
+            return result;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'operators');
+        }
+    },
+    async getAvailableCredit({ user, token }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(token, 'token');
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'getAvailableCredit',
+                args: [user, token]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getAvailableCredit');
+        }
+    },
+    async getDeposit() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'getDeposit',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getDeposit');
+        }
+    },
+    async getLatestSlash({ operator }) {
+        try {
+            validateAddress(operator, 'operator');
+            const res = await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'getLatestSlash',
+                args: [operator]
+            });
+            if (Array.isArray(res)) {
+                return {
+                    timestamp: res[0],
+                    amount: res[1],
+                    reputationLoss: res[2],
+                    reason: res[3],
+                    level: res[4]
+                };
+            }
+            return res;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getLatestSlash');
+        }
+    },
+    async getSlashCount({ operator }) {
+        try {
+            validateAddress(operator, 'operator');
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'getSlashCount',
+                args: [operator]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getSlashCount');
+        }
+    },
+    async getSlashHistory({ operator }) {
+        try {
+            validateAddress(operator, 'operator');
+            const res = await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'getSlashHistory',
+                args: [operator]
+            });
+            return res.map(r => {
+                if (Array.isArray(r)) {
+                    return {
+                        timestamp: r[0],
+                        amount: r[1],
+                        reputationLoss: r[2],
+                        reason: r[3],
+                        level: r[4]
+                    };
+                }
+                return r;
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getSlashHistory');
+        }
+    },
+    async slashHistory({ operator, index }) {
+        try {
+            validateAddress(operator, 'operator');
+            validateRequired(index, 'index');
+            const res = await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'slashHistory',
+                args: [operator, index]
+            });
+            if (Array.isArray(res)) {
+                return {
+                    timestamp: res[0],
+                    amount: res[1],
+                    reputationLoss: res[2],
+                    reason: res[3],
+                    level: res[4]
+                };
+            }
+            return res;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'slashHistory');
+        }
+    },
+    async userOpState({ user, operator }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(operator, 'operator');
+            const res = await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'userOpState',
+                args: [user, operator]
+            });
+            if (Array.isArray(res)) {
+                return { lastTimestamp: Number(res[0]), isBlocked: res[1] };
+            }
+            return { lastTimestamp: Number(res.lastTimestamp), isBlocked: res.isBlocked };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'userOpState');
+        }
+    },
+    async cachedPrice() {
+        try {
+            const res = await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'cachedPrice',
+                args: []
+            });
+            if (Array.isArray(res)) {
+                return {
+                    price: res[0],
+                    updatedAt: res[1],
+                    roundId: res[2],
+                    decimals: res[3]
+                };
+            }
+            return res;
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'cachedPrice');
+        }
+    },
+    async aPNTsPriceUSD() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'aPNTsPriceUSD',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'aPNTsPriceUSD');
+        }
+    },
+    async protocolFeeBPS() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'protocolFeeBPS',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'protocolFeeBPS');
+        }
+    },
+    async protocolRevenue() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'protocolRevenue',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'protocolRevenue');
+        }
+    },
+    async totalTrackedBalance() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'totalTrackedBalance',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'totalTrackedBalance');
+        }
+    },
+    async priceStalenessThreshold() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'priceStalenessThreshold',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'priceStalenessThreshold');
+        }
+    },
+    async sbtHolders({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'sbtHolders',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'sbtHolders');
+        }
     },
     // Constants
-    async superPaymasterAPNTS_TOKEN() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'APNTS_TOKEN',
-            args: []
-        });
-    },
-    async superPaymasterREGISTRY() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'REGISTRY',
-            args: []
-        });
-    },
-    async superPaymasterBLS_AGGREGATOR() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'BLS_AGGREGATOR',
-            args: []
-        });
-    },
-    async superPaymasterETH_USD_PRICE_FEED() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'ETH_USD_PRICE_FEED',
-            args: []
-        });
-    },
-    async superPaymasterPAYMASTER_DATA_OFFSET() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'PAYMASTER_DATA_OFFSET',
-            args: []
-        });
-    },
-    async superPaymasterRATE_OFFSET() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'RATE_OFFSET',
-            args: []
-        });
-    },
-    async superPaymasterBPS_DENOMINATOR() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'BPS_DENOMINATOR',
-            args: []
-        });
-    },
-    async superPaymasterPRICE_CACHE_DURATION() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'PRICE_CACHE_DURATION',
-            args: []
-        });
-    },
-    async superPaymasterPRICE_STALENESS_THRESHOLD() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'PRICE_STALENESS_THRESHOLD',
-            args: []
-        });
-    },
-    async superPaymasterMAX_ETH_USD_PRICE() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'MAX_ETH_USD_PRICE',
-            args: []
-        });
-    },
-    async superPaymasterMIN_ETH_USD_PRICE() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'MIN_ETH_USD_PRICE',
-            args: []
-        });
+    async APNTS_TOKEN() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'APNTS_TOKEN',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'APNTS_TOKEN');
+        }
+    },
+    async REGISTRY() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'REGISTRY',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'REGISTRY');
+        }
+    },
+    async BLS_AGGREGATOR() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'BLS_AGGREGATOR',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'BLS_AGGREGATOR');
+        }
+    },
+    async ETH_USD_PRICE_FEED() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'ETH_USD_PRICE_FEED',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ETH_USD_PRICE_FEED');
+        }
+    },
+    async treasury() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'treasury',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'treasury');
+        }
+    },
+    async xpntsFactory() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'xpntsFactory',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'xpntsFactory');
+        }
+    },
+    async entryPoint() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'entryPoint',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'entryPoint');
+        }
+    },
+    async MAX_PROTOCOL_FEE() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'MAX_PROTOCOL_FEE',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MAX_PROTOCOL_FEE');
+        }
+    },
+    async MAX_ETH_USD_PRICE() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'MAX_ETH_USD_PRICE',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MAX_ETH_USD_PRICE');
+        }
+    },
+    async MIN_ETH_USD_PRICE() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'MIN_ETH_USD_PRICE',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MIN_ETH_USD_PRICE');
+        }
+    },
+    async PAYMASTER_DATA_OFFSET() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'PAYMASTER_DATA_OFFSET',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'PAYMASTER_DATA_OFFSET');
+        }
+    },
+    async PRICE_CACHE_DURATION() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'PRICE_CACHE_DURATION',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'PRICE_CACHE_DURATION');
+        }
+    },
+    async RATE_OFFSET() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'RATE_OFFSET',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'RATE_OFFSET');
+        }
+    },
+    async VALIDATION_BUFFER_BPS() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'VALIDATION_BUFFER_BPS',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'VALIDATION_BUFFER_BPS');
+        }
+    },
+    async BPS_DENOMINATOR() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'BPS_DENOMINATOR',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'BPS_DENOMINATOR');
+        }
     },
     // Admin
-    async transferSuperPaymasterOwnership({ newOwner, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'transferOwnership',
-            args: [newOwner],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterOwner() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'owner',
-            args: []
-        });
-    },
-    async renounceSuperPaymasterOwnership({ account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'renounceOwnership',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Additional Operator Management
-    async superPaymasterSetOperatorLimits({ operator, limits, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setOperatorLimits',
-            args: [operator, limits],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterSlashOperator({ operator, amount, reason, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'slashOperator',
-            args: [operator, amount, reason],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // User Management
-    async superPaymasterUpdateBlockedStatus({ user, blocked, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'updateBlockedStatus',
-            args: [user, blocked],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Additional View Functions
-    async superPaymasterProtocolFeeBPS() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'protocolFeeBPS',
-            args: []
-        });
-    },
-    async superPaymasterProtocolRevenue() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'protocolRevenue',
-            args: []
-        });
-    },
-    async superPaymasterTreasury() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'treasury',
-            args: []
-        });
-    },
-    async superPaymasterXpntsFactory() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'xpntsFactory',
-            args: []
-        });
-    },
-    async superPaymasterTotalTrackedBalance() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'totalTrackedBalance',
-            args: []
-        });
-    },
-    async superPaymasterLastUserOpTimestamp({ user }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'lastUserOpTimestamp',
-            args: [user]
-        });
-    },
-    // Slash History
-    async superPaymasterGetSlashHistory({ operator }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'getSlashHistory',
-            args: [operator]
-        });
-    },
-    async superPaymasterGetSlashCount({ operator }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'getSlashCount',
-            args: [operator]
-        });
-    },
-    async superPaymasterGetLatestSlash({ operator }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'getLatestSlash',
-            args: [operator]
-        });
-    },
-    async superPaymasterSlashHistory({ operator, index }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'slashHistory',
-            args: [operator, index]
-        });
-    },
-    // Price Management
-    async superPaymasterUpdatePrice({ account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'updatePrice',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterUpdatePriceDVT({ price, proof, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'updatePriceDVT',
-            args: [price, proof],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Treasury & Revenue
-    async superPaymasterSetTreasury({ treasury, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setTreasury',
-            args: [treasury],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterWithdrawProtocolRevenue({ to, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'withdrawProtocolRevenue',
-            args: [to],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Factory & Config
-    async superPaymasterSetXPNTsFactory({ factory, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setXPNTsFactory',
-            args: [factory],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterSetAPNTsToken({ token, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setAPNTsToken',
-            args: [token],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterSetBLSAggregator({ aggregator, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'setBLSAggregator',
-            args: [aggregator],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Transfer callback
-    async superPaymasterOnTransferReceived({ from, amount, data }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'onTransferReceived',
-            args: [from, amount, data]
-        });
-    },
-    // Withdraw alias
-    async superPaymasterWithdrawAPNTs({ amount, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'withdraw',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async superPaymasterVersion() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'version',
-            args: []
-        });
-    },
-    // Aliases including implementation
-    async superPaymasterAddStake(args) { return this.superPaymasterDepositFor(args); },
-    async superPaymasterDepositForAlias(args) { return this.superPaymasterDepositFor(args); },
-    async superPaymasterUnlockStake(args) { return this.superPaymasterUnlockSuperStake(args); },
-    async superPaymasterWithdrawAlias(args) { return this.superPaymasterWithdraw(args); },
-    async superPaymasterMAX_PROTOCOL_FEE() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'MAX_PROTOCOL_FEE',
-            args: []
-        });
-    },
-    async superPaymasterVALIDATION_BUFFER_BPS() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'VALIDATION_BUFFER_BPS',
-            args: []
-        });
-    },
-    async superPaymasterPriceStalenessThreshold() {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'priceStalenessThreshold', // Assuming ABI has this exact name
-            args: []
-        });
-    },
-    async superPaymasterSbtHolders({ user }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'sbtHolders',
-            args: [user]
-        });
-    },
-    async superPaymasterUserOpState({ userOpHash }) {
-        return client.readContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'userOpState',
-            args: [userOpHash]
-        });
-    },
-    async superPaymasterUpdateSBTStatus({ user, hasSBT, account }) {
-        return client.writeContract({
-            address,
-            abi: SuperPaymasterABI,
-            functionName: 'updateSBTStatus',
-            args: [user, hasSBT],
-            account: account,
-            chain: client.chain
-        });
+    async owner() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'owner',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'owner');
+        }
+    },
+    async transferOwnership({ newOwner, account }) {
+        try {
+            validateAddress(newOwner, 'newOwner');
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'transferOwnership',
+                args: [newOwner],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'transferOwnership');
+        }
+    },
+    async renounceOwnership({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'renounceOwnership',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'renounceOwnership');
+        }
+    },
+    async version() {
+        try {
+            return await client.readContract({
+                address,
+                abi: SuperPaymasterABI,
+                functionName: 'version',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'version');
+        }
     }
 });