@aastar/core 0.16.8 → 0.16.11

package/dist/actions/dvt.js

@@ -1,41 +1,241 @@
 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]
-        });
+import { validateAddress, validateRequired } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
+export const dvtActions = (address) => (client) => ({
+    // Proposal Management
+    async createSlashProposal({ operator, level, reason, account }) {
+        try {
+            validateAddress(operator, 'operator');
+            validateRequired(reason, 'reason');
+            return await client.writeContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'createProposal',
+                args: [operator, level, reason],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'createSlashProposal');
+        }
+    },
+    async signSlashProposal({ proposalId, signature, account }) {
+        try {
+            validateRequired(proposalId, 'proposalId');
+            validateRequired(signature, 'signature');
+            return await client.writeContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'signSlashProposal',
+                args: [proposalId, signature],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'signSlashProposal');
+        }
+    },
+    async executeSlashWithProof({ proposalId, repUsers, newScores, epoch, proof, account }) {
+        try {
+            validateRequired(proposalId, 'proposalId');
+            validateRequired(repUsers, 'repUsers');
+            validateRequired(newScores, 'newScores');
+            validateRequired(epoch, 'epoch');
+            validateRequired(proof, 'proof');
+            return await client.writeContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'executeWithProof',
+                args: [proposalId, repUsers, newScores, epoch, proof],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'executeSlashWithProof');
+        }
+    },
+    async markProposalExecuted({ id, account }) {
+        try {
+            validateRequired(id, 'id');
+            return await client.writeContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'markProposalExecuted',
+                args: [id],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'markProposalExecuted');
+        }
+    },
+    async proposals({ proposalId }) {
+        try {
+            validateRequired(proposalId, 'proposalId');
+            const result = await client.readContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'proposals',
+                args: [proposalId]
+            });
+            return {
+                operator: result[0],
+                slashLevel: Number(result[1]),
+                reason: result[2],
+                executed: result[3]
+            };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'proposals');
+        }
+    },
+    async nextProposalId() {
+        try {
+            return await client.readContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'nextProposalId',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'nextProposalId');
+        }
+    },
+    // Validator Management
+    async isValidator({ user }) {
+        try {
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'isValidator',
+                args: [user]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'isValidator');
+        }
+    },
+    async addValidator({ v, account }) {
+        try {
+            validateAddress(v, 'v');
+            return await client.writeContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'addValidator',
+                args: [v],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'addValidator');
+        }
+    },
+    // BLS Aggregator Integration
+    async setBLSAggregator({ aggregator, account }) {
+        try {
+            validateAddress(aggregator, 'aggregator');
+            return await client.writeContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'setBLSAggregator',
+                args: [aggregator],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setBLSAggregator');
+        }
+    },
+    async BLS_AGGREGATOR() {
+        try {
+            return await client.readContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'BLS_AGGREGATOR',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'BLS_AGGREGATOR');
+        }
+    },
+    async REGISTRY() {
+        try {
+            return await client.readContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'REGISTRY',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'REGISTRY');
+        }
+    },
+    // Ownership
+    async owner() {
+        try {
+            return await client.readContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'owner',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'owner');
+        }
+    },
+    async transferOwnership({ newOwner, account }) {
+        try {
+            validateAddress(newOwner, 'newOwner');
+            return await client.writeContract({
+                address,
+                abi: DVTValidatorABI,
+                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: DVTValidatorABI,
+                functionName: 'renounceOwnership',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'renounceOwnership');
+        }
+    },
+    async version() {
+        try {
+            return await client.readContract({
+                address,
+                abi: DVTValidatorABI,
+                functionName: 'version',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'version');
+        }
     }
 });

package/dist/actions/entryPoint.d.ts

@@ -1,4 +1,4 @@
-import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+import { type Address, type PublicClient, type WalletClient, type Hash, type Account } from 'viem';
 export declare enum EntryPointVersion {
     V06 = "0.6",
     V07 = "0.7"
@@ -25,66 +25,6 @@ export type EntryPointActions = {
         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;
+    entryPointAddress: Address;
 };
-export declare const entryPointActions: (address: Address, version?: EntryPointVersion) => (client: PublicClient | WalletClient) => EntryPointActions;
+export declare const entryPointActions: (address: Address) => (client: PublicClient | WalletClient) => EntryPointActions;

package/dist/actions/entryPoint.js

@@ -1,211 +1,79 @@
 import { EntryPointABI } from '../abis/index.js';
+import { validateAddress, validateRequired, validateAmount } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
 export var EntryPointVersion;
 (function (EntryPointVersion) {
     EntryPointVersion["V06"] = "0.6";
     EntryPointVersion["V07"] = "0.7";
 })(EntryPointVersion || (EntryPointVersion = {}));
-export const entryPointActions = (address, version = EntryPointVersion.V07) => (client) => ({
-    version,
+export const entryPointActions = (address) => (client) => ({
+    entryPointAddress: address,
     async balanceOf({ account }) {
-        // v0.6 and v0.7 both use balanceOf(address)
-        return client.readContract({
-            address,
-            abi: [{ name: 'balanceOf', inputs: [{ type: 'address' }], outputs: [{ type: 'uint256' }], type: 'function', stateMutability: 'view' }],
-            functionName: 'balanceOf',
-            args: [account]
-        });
+        try {
+            validateAddress(account, 'account');
+            return await client.readContract({
+                address,
+                abi: EntryPointABI,
+                functionName: 'balanceOf',
+                args: [account]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'balanceOf');
+        }
     },
     async depositTo({ account, amount, txAccount }) {
-        // v0.6 and v0.7 both use depositTo(address)
-        return client.writeContract({
-            address,
-            abi: [{ name: 'depositTo', type: 'function', inputs: [{ type: 'address' }], outputs: [], stateMutability: 'payable' }],
-            functionName: 'depositTo',
-            args: [account],
-            value: amount,
-            account: txAccount,
-            chain: client.chain
-        });
-    },
-    async getNonce({ sender, key }) {
-        if (version === EntryPointVersion.V06) {
-            // v0.6: getNonce(address, uint192)
-            return client.readContract({
+        try {
+            validateAddress(account, 'account');
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
                 address,
-                abi: [{ name: 'getNonce', type: 'function', inputs: [{ type: 'address', name: 'sender' }, { type: 'uint256', name: 'key' }], outputs: [{ type: 'uint256' }], stateMutability: 'view' }],
-                functionName: 'getNonce',
-                args: [sender, key]
+                abi: EntryPointABI,
+                functionName: 'depositTo',
+                args: [account],
+                value: amount,
+                account: txAccount,
+                chain: client.chain
             });
         }
-        else {
-            // v0.7: getNonce(address, uint192) - Note: v0.7 actually uses 192 bit key but in ABI it's uint192
-            return client.readContract({
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'depositTo');
+        }
+    },
+    async getNonce({ sender, key }) {
+        try {
+            validateAddress(sender, 'sender');
+            validateRequired(key, 'key');
+            return await client.readContract({
                 address,
-                abi: [{ name: 'getNonce', type: 'function', inputs: [{ type: 'address', name: 'sender' }, { type: 'uint192', name: 'key' }], outputs: [{ type: 'uint256' }], stateMutability: 'view' }],
+                abi: EntryPointABI,
                 functionName: 'getNonce',
                 args: [sender, key]
             });
         }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getNonce');
+        }
     },
     async getDepositInfo({ account }) {
-        const result = await client.readContract({
-            address,
-            abi: [{
-                    name: 'getDepositInfo',
-                    type: 'function',
-                    inputs: [{ type: 'address', name: 'account' }],
-                    outputs: [
-                        { type: 'uint112', name: 'deposit' },
-                        { type: 'bool', name: 'staked' },
-                        { type: 'uint112', name: 'stake' },
-                        { type: 'uint32', name: 'unstakeDelaySec' },
-                        { type: 'uint48', name: 'withdrawTime' }
-                    ],
-                    stateMutability: 'view'
-                }],
-            functionName: 'getDepositInfo',
-            args: [account]
-        });
-        return {
-            deposit: result[0],
-            staked: result[1],
-            stake: result[2],
-            unstakeDelaySec: result[3],
-            withdrawTime: result[4]
-        };
-    },
-    async addStake({ unstakeDelaySec, amount, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'addStake',
-            args: [unstakeDelaySec],
-            value: amount,
-            account: account,
-            chain: client.chain
-        });
-    },
-    async unlockStake({ account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'unlockStake',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async withdrawStake({ withdrawAddress, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'withdrawStake',
-            args: [withdrawAddress],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async withdrawTo({ withdrawAddress, amount, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'withdrawTo',
-            args: [withdrawAddress, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async handleOps({ ops, beneficiary, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'handleOps',
-            args: [ops, beneficiary],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async handleAggregatedOps({ opsPerAggregator, beneficiary, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'handleAggregatedOps',
-            args: [opsPerAggregator, beneficiary],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async innerHandleOp({ callData, opInfo, context, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'innerHandleOp',
-            args: [callData, opInfo, context],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async delegateAndRevert({ target, data, account }) {
-        // This typically reverts, but we act as a writer
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'delegateAndRevert',
-            args: [target, data],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async getUserOpHash({ op }) {
-        return client.readContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'getUserOpHash',
-            args: [op]
-        });
-    },
-    async getSenderAddress({ initCode }) {
-        // getSenderAddress usually reverts with the address. Viem might throw.
-        // But let's assume standard call first.
-        // Actually in EP v0.7 it might return if called off-chain or revert.
-        // We will try readContract. 
         try {
-            return await client.readContract({
+            validateAddress(account, 'account');
+            const result = await client.readContract({
                 address,
                 abi: EntryPointABI,
-                functionName: 'getSenderAddress',
-                args: [initCode]
+                functionName: 'getDepositInfo',
+                args: [account]
             });
+            return {
+                deposit: result.deposit,
+                staked: result.staked,
+                stake: result.stake,
+                unstakeDelaySec: result.unstakeDelaySec,
+                withdrawTime: result.withdrawTime
+            };
         }
-        catch (e) {
-            // Extract address from error if needed, but for now just implementing the method call.
-            // Usually this method reverts with SenderAddressResult(address)
-            throw e;
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getDepositInfo');
         }
-    },
-    async senderCreator() {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'senderCreator', args: [] });
-    },
-    async incrementNonce({ key, account }) {
-        return client.writeContract({ address, abi: EntryPointABI, functionName: 'incrementNonce', args: [key], account: account, chain: client.chain });
-    },
-    async nonceSequenceNumber({ sender, key }) {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'nonceSequenceNumber', args: [sender, key] });
-    },
-    async supportsInterface({ interfaceId }) {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'supportsInterface', args: [interfaceId] });
-    },
-    async eip712Domain() {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'eip712Domain', args: [] });
-    },
-    async getCurrentUserOpHash() {
-        // View that returns 'bytes32'
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'getCurrentUserOpHash', args: [] });
-    },
-    async getDomainSeparatorV4() {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'getDomainSeparatorV4', args: [] });
-    },
-    async getPackedUserOpTypeHash() {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'getPackedUserOpTypeHash', args: [] });
     }
 });