@aastar/core 0.16.7

package/dist/actions/validators.js

@@ -0,0 +1,433 @@
+import { DVTValidatorABI, BLSAggregatorABI } from '../abis/index.js';
+export const dvtActions = (address) => (client) => ({
+    async createProposal({ target, calldata, description, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'createProposal',
+            args: [target, calldata, description],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async signProposal({ proposalId, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'signProposal',
+            args: [proposalId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async executeWithProof({ proposalId, signatures, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'executeWithProof',
+            args: [proposalId, signatures],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async cancelProposal({ proposalId, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'cancelProposal',
+            args: [proposalId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async isValidator({ validator }) {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'isValidator',
+            args: [validator]
+        });
+    },
+    async addValidator({ validator, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'addValidator',
+            args: [validator],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async removeValidator({ validator, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'removeValidator',
+            args: [validator],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getValidators() {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'getValidators',
+            args: []
+        });
+    },
+    async getValidatorCount() {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'getValidatorCount',
+            args: []
+        });
+    },
+    async getProposal({ proposalId }) {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'getProposal',
+            args: [proposalId]
+        });
+    },
+    async getProposalCount() {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'getProposalCount',
+            args: []
+        });
+    },
+    async getProposalState({ proposalId }) {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'getProposalState',
+            args: [proposalId]
+        });
+    },
+    async getSignatureCount({ proposalId }) {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'getSignatureCount',
+            args: [proposalId]
+        });
+    },
+    async hasVoted({ proposalId, validator }) {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'hasVoted',
+            args: [proposalId, validator]
+        });
+    },
+    async proposals({ proposalId }) {
+        return client.readContract({ address, abi: DVTValidatorABI, functionName: 'proposals', args: [proposalId] });
+    },
+    async nextProposalId() {
+        return client.readContract({ address, abi: DVTValidatorABI, functionName: 'nextProposalId', args: [] });
+    },
+    async threshold() {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'threshold',
+            args: []
+        });
+    },
+    async setThreshold({ newThreshold, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'setThreshold',
+            args: [newThreshold],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setBLSAggregator({ aggregator, account }) {
+        return client.writeContract({ address, abi: DVTValidatorABI, functionName: 'setBLSAggregator', args: [aggregator], account: account, chain: client.chain });
+    },
+    async markProposalExecuted({ proposalId, account }) {
+        return client.writeContract({ address, abi: DVTValidatorABI, functionName: 'markProposalExecuted', args: [proposalId], account: account, chain: client.chain });
+    },
+    async BLS_AGGREGATOR() {
+        return client.readContract({ address, abi: DVTValidatorABI, functionName: 'BLS_AGGREGATOR', args: [] });
+    },
+    async owner() {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async transferOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async renounceOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async version() {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});
+export const blsActions = (address) => (client) => ({
+    async aggregatedSignatures({ requestId }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'aggregatedSignatures',
+            args: [requestId]
+        });
+    },
+    async registerBLSPublicKey({ publicKey, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'registerBLSPublicKey',
+            args: [publicKey],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registerOperator({ operator, blsPublicKey, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'registerOperator',
+            args: [operator, blsPublicKey],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async deregisterBLSPublicKey({ account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'deregisterBLSPublicKey',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async updatePublicKey({ newKey, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'updatePublicKey',
+            args: [newKey],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async aggregateSignatures({ signatures }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'aggregateSignatures',
+            args: [signatures]
+        });
+    },
+    async verifyAggregatedSignature({ message, aggregatedSignature, publicKeys }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'verifyAggregatedSignature',
+            args: [message, aggregatedSignature, publicKeys]
+        });
+    },
+    async validateSignature({ message, signature, publicKey }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'validateSignature',
+            args: [message, signature, publicKey]
+        });
+    },
+    async executeProposal({ proposalId, signatures, account }) {
+        return client.writeContract({ address, abi: BLSAggregatorABI, functionName: 'executeProposal', args: [proposalId, signatures], account: account, chain: client.chain });
+    },
+    async verifyAndExecute({ proposalId, signatures, account }) {
+        return client.writeContract({ address, abi: BLSAggregatorABI, functionName: 'verifyAndExecute', args: [proposalId, signatures], account: account, chain: client.chain });
+    },
+    async getPublicKey({ address: userAddress }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'getPublicKey',
+            args: [userAddress]
+        });
+    },
+    async getPublicKeys({ addresses }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'getPublicKeys',
+            args: [addresses]
+        });
+    },
+    async getAggregatedPublicKey({ addresses }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'getAggregatedPublicKey',
+            args: [addresses]
+        });
+    },
+    async isKeyRegistered({ address: userAddress }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'isKeyRegistered',
+            args: [userAddress]
+        });
+    },
+    async getRegisteredCount() {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'getRegisteredCount',
+            args: []
+        });
+    },
+    async blsPublicKeys({ address: userAddress }) {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'blsPublicKeys', args: [userAddress] });
+    },
+    async threshold() {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'threshold',
+            args: []
+        });
+    },
+    async minThreshold() {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'minThreshold', args: [] });
+    },
+    async defaultThreshold() {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'defaultThreshold', args: [] });
+    },
+    async setThreshold({ newThreshold, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'setThreshold',
+            args: [newThreshold],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setMinThreshold({ newThreshold, account }) {
+        return client.writeContract({ address, abi: BLSAggregatorABI, functionName: 'setMinThreshold', args: [newThreshold], account: account, chain: client.chain });
+    },
+    async setDefaultThreshold({ newThreshold, account }) {
+        return client.writeContract({ address, abi: BLSAggregatorABI, functionName: 'setDefaultThreshold', args: [newThreshold], account: account, chain: client.chain });
+    },
+    async setRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setDVTValidator({ validator, account }) {
+        return client.writeContract({ address, abi: BLSAggregatorABI, functionName: 'setDVTValidator', args: [validator], account: account, chain: client.chain });
+    },
+    async setSuperPaymaster({ paymaster, account }) {
+        return client.writeContract({ address, abi: BLSAggregatorABI, functionName: 'setSuperPaymaster', args: [paymaster], account: account, chain: client.chain });
+    },
+    async renounceOwnership({ account }) {
+        return client.writeContract({ address, abi: BLSAggregatorABI, functionName: 'renounceOwnership', args: [], account: account, chain: client.chain });
+    },
+    async REGISTRY() {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    async DVT_VALIDATOR() {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'DVT_VALIDATOR', args: [] });
+    },
+    async SUPERPAYMASTER() {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'SUPERPAYMASTER', args: [] });
+    },
+    async MAX_VALIDATORS() {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'MAX_VALIDATORS', args: [] });
+    },
+    async executedProposals({ proposalId }) {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'executedProposals', args: [proposalId] });
+    },
+    async proposalNonces({ proposalId }) {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'proposalNonces', args: [proposalId] });
+    },
+    async getRequestStatus({ requestId }) {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'getRequestStatus', args: [requestId] });
+    },
+    async getOperatorId({ operator }) {
+        return client.readContract({ address, abi: BLSAggregatorABI, functionName: 'getOperatorId', args: [operator] });
+    },
+    async owner() {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async transferOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async version() {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});

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

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

package/dist/actions/validators.test.js

@@ -0,0 +1,215 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { dvtActions, blsActions } from './validators.js';
+describe('Validator Actions', () => {
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_VALIDATOR = '0x1111111111111111111111111111111111111111';
+    const MOCK_TARGET = '0x2222222222222222222222222222222222222222';
+    const MOCK_USER = '0x3333333333333333333333333333333333333333';
+    const MOCK_PROPOSAL_ID = 1n;
+    beforeEach(() => {
+        mockAccount = {
+            address: MOCK_USER,
+            type: 'json-rpc'
+        };
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+    describe('dvtActions', () => {
+        it('should create proposal', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions(MOCK_VALIDATOR)(mockWalletClient);
+            const result = await actions.createProposal({
+                target: MOCK_TARGET,
+                calldata: '0x',
+                description: 'test',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should sign proposal', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions(MOCK_VALIDATOR)(mockWalletClient);
+            const result = await actions.signProposal({ proposalId: MOCK_PROPOSAL_ID, account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should execute with proof', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions(MOCK_VALIDATOR)(mockWalletClient);
+            const result = await actions.executeWithProof({
+                proposalId: MOCK_PROPOSAL_ID,
+                signatures: ['0x123'],
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should cancel proposal', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions(MOCK_VALIDATOR)(mockWalletClient);
+            const result = await actions.cancelProposal({ proposalId: MOCK_PROPOSAL_ID, account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should query validator info', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(true) // isValidator
+                .mockResolvedValueOnce(['0xV1']) // getValidators
+                .mockResolvedValueOnce(1n); // getValidatorCount
+            const actions = dvtActions(MOCK_VALIDATOR)(mockPublicClient);
+            expect(await actions.isValidator({ validator: MOCK_USER })).toBe(true);
+            expect(await actions.getValidators()).toEqual(['0xV1']);
+            expect(await actions.getValidatorCount()).toBe(1n);
+        });
+        it('should query proposal details', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce({ id: 1n }) // getProposal
+                .mockResolvedValueOnce(1n) // getProposalCount
+                .mockResolvedValueOnce(1) // getProposalState
+                .mockResolvedValueOnce(5n) // getSignatureCount
+                .mockResolvedValueOnce(true); // hasVoted
+            const actions = dvtActions(MOCK_VALIDATOR)(mockPublicClient);
+            const prop = await actions.getProposal({ proposalId: MOCK_PROPOSAL_ID });
+            expect(prop.id).toBe(1n);
+            expect(await actions.getProposalCount()).toBe(1n);
+            expect(await actions.getProposalState({ proposalId: MOCK_PROPOSAL_ID })).toBe(1);
+            expect(await actions.getSignatureCount({ proposalId: MOCK_PROPOSAL_ID })).toBe(5n);
+            expect(await actions.hasVoted({ proposalId: MOCK_PROPOSAL_ID, validator: MOCK_USER })).toBe(true);
+        });
+        it('should manage validators and threshold', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions(MOCK_VALIDATOR)(mockWalletClient);
+            expect(await actions.addValidator({ validator: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.removeValidator({ validator: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.setThreshold({ newThreshold: 2n, account: mockAccount })).toBe(txHash);
+        });
+        it('should system config and view', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(3n) // threshold
+                .mockResolvedValueOnce(MOCK_USER) // owner
+                .mockResolvedValueOnce('v1'); // version
+            const actions = dvtActions(MOCK_VALIDATOR)(mockPublicClient);
+            expect(await actions.threshold()).toBe(3n);
+            expect(await actions.owner()).toBe(MOCK_USER);
+            expect(await actions.version()).toBe('v1');
+        });
+        it('should call admin setters', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions(MOCK_VALIDATOR)(mockWalletClient);
+            expect(await actions.setRegistry({ registry: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.setBLSAggregator({ aggregator: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.markProposalExecuted({ proposalId: 1n, account: mockAccount })).toBe(txHash);
+            expect(await actions.transferOwnership({ newOwner: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.renounceOwnership({ account: mockAccount })).toBe(txHash);
+        });
+        it('should call views', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce({}) // proposals
+                .mockResolvedValueOnce(2n) // nextProposalId
+                .mockResolvedValueOnce(MOCK_USER); // BLS_AGGREGATOR
+            const actions = dvtActions(MOCK_VALIDATOR)(mockPublicClient);
+            expect(await actions.proposals({ proposalId: 1n })).toEqual({});
+            expect(await actions.nextProposalId()).toBe(2n);
+            expect(await actions.BLS_AGGREGATOR()).toBe(MOCK_USER);
+        });
+    });
+    describe('blsActions', () => {
+        const MOCK_BLS = '0x4444444444444444444444444444444444444444';
+        const MOCK_KEY = '0x1234';
+        it('should manage BLS public keys', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = blsActions(MOCK_BLS)(mockWalletClient);
+            expect(await actions.registerBLSPublicKey({ publicKey: MOCK_KEY, account: mockAccount })).toBe(txHash);
+            expect(await actions.deregisterBLSPublicKey({ account: mockAccount })).toBe(txHash);
+            expect(await actions.updatePublicKey({ newKey: MOCK_KEY, account: mockAccount })).toBe(txHash);
+        });
+        it('should aggregate and verify signatures', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce('0xagg') // aggregateSignatures
+                .mockResolvedValueOnce(true) // verifyAggregatedSignature
+                .mockResolvedValueOnce(true); // validateSignature
+            const actions = blsActions(MOCK_BLS)(mockPublicClient);
+            expect(await actions.aggregateSignatures({ signatures: ['0x1'] })).toBe('0xagg');
+            expect(await actions.verifyAggregatedSignature({ message: '0x', aggregatedSignature: '0x', publicKeys: ['0x'] })).toBe(true);
+            expect(await actions.validateSignature({ message: '0x', signature: '0x', publicKey: '0x' })).toBe(true);
+        });
+        it('should query public keys and status', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(MOCK_KEY) // getPublicKey
+                .mockResolvedValueOnce([MOCK_KEY]) // getPublicKeys
+                .mockResolvedValueOnce(MOCK_KEY) // getAggregatedPublicKey
+                .mockResolvedValueOnce(true) // isKeyRegistered
+                .mockResolvedValueOnce(10n); // getRegisteredCount
+            const actions = blsActions(MOCK_BLS)(mockPublicClient);
+            expect(await actions.getPublicKey({ address: MOCK_USER })).toBe(MOCK_KEY);
+            expect(await actions.getPublicKeys({ addresses: [MOCK_USER] })).toEqual([MOCK_KEY]);
+            expect(await actions.getAggregatedPublicKey({ addresses: [MOCK_USER] })).toBe(MOCK_KEY);
+            expect(await actions.isKeyRegistered({ address: MOCK_USER })).toBe(true);
+            expect(await actions.getRegisteredCount()).toBe(10n);
+        });
+        it('should manage threshold and system', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = blsActions(MOCK_BLS)(mockWalletClient);
+            expect(await actions.setThreshold({ newThreshold: 5n, account: mockAccount })).toBe(txHash);
+            expect(await actions.setRegistry({ registry: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.transferOwnership({ newOwner: MOCK_USER, account: mockAccount })).toBe(txHash);
+        });
+        it('should call proposal execution extensions', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = blsActions(MOCK_BLS)(mockWalletClient);
+            expect(await actions.executeProposal({ proposalId: 1n, signatures: ['0x'], account: mockAccount })).toBe(txHash);
+            expect(await actions.verifyAndExecute({ proposalId: 1n, signatures: ['0x'], account: mockAccount })).toBe(txHash);
+        });
+        it('should manage thresholds extended', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = blsActions(MOCK_BLS)(mockWalletClient);
+            expect(await actions.setMinThreshold({ newThreshold: 2n, account: mockAccount })).toBe(txHash);
+            expect(await actions.setDefaultThreshold({ newThreshold: 3n, account: mockAccount })).toBe(txHash);
+            expect(await actions.setDVTValidator({ validator: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.setSuperPaymaster({ paymaster: MOCK_USER, account: mockAccount })).toBe(txHash);
+            expect(await actions.renounceOwnership({ account: mockAccount })).toBe(txHash);
+        });
+        it('should call extended views', async () => {
+            mockPublicClient.readContract
+                .mockResolvedValueOnce(['0x']) // blsPublicKeys
+                .mockResolvedValueOnce(1n) // threshold
+                .mockResolvedValueOnce(1n) // minThreshold
+                .mockResolvedValueOnce(1n) // defaultThreshold
+                .mockResolvedValueOnce(MOCK_USER) // REGISTRY
+                .mockResolvedValueOnce(MOCK_USER) // DVT_VALIDATOR
+                .mockResolvedValueOnce(MOCK_USER) // SUPERPAYMASTER
+                .mockResolvedValueOnce(10n) // MAX_VALIDATORS
+                .mockResolvedValueOnce(true) // executedProposals
+                .mockResolvedValueOnce(0n) // proposalNonces
+                .mockResolvedValueOnce(MOCK_USER) // owner
+                .mockResolvedValueOnce('v1'); // version
+            const actions = blsActions(MOCK_BLS)(mockPublicClient);
+            expect(await actions.blsPublicKeys({ address: MOCK_USER })).toEqual(['0x']);
+            expect(await actions.threshold()).toBe(1n);
+            expect(await actions.minThreshold()).toBe(1n);
+            expect(await actions.defaultThreshold()).toBe(1n);
+            expect(await actions.REGISTRY()).toBe(MOCK_USER);
+            expect(await actions.DVT_VALIDATOR()).toBe(MOCK_USER);
+            expect(await actions.SUPERPAYMASTER()).toBe(MOCK_USER);
+            expect(await actions.MAX_VALIDATORS()).toBe(10n);
+            expect(await actions.executedProposals({ proposalId: 1n })).toBe(true);
+            expect(await actions.proposalNonces({ proposalId: 1n })).toBe(0n);
+            expect(await actions.owner()).toBe(MOCK_USER);
+            expect(await actions.version()).toBe('v1');
+        });
+    });
+});

package/dist/branding.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AAStar Community Branding Configuration
+ */
+export declare const BRANDING: {
+    readonly logo: "https://raw.githubusercontent.com/jhfnetboy/MarkDownImg/main/img/202505031325963.png";
+    readonly icon: "https://www.aastar.io/favicon.ico";
+    readonly colors: {
+        readonly primary: "#FF6B35";
+        readonly primaryLight: "#FF8C42";
+        readonly secondary: "#4A90E2";
+        readonly secondaryDark: "#357ABD";
+        readonly success: "#4CAF50";
+        readonly warning: "#FFC107";
+        readonly error: "#F44336";
+        readonly gray50: "#F9FAFB";
+        readonly gray100: "#F3F4F6";
+        readonly gray700: "#374151";
+        readonly gray800: "#1F2937";
+        readonly gray900: "#111827";
+    };
+};
+export declare const LINKS: {
+    readonly main: "https://aastar.io";
+    readonly airAccount: "https://airAccount.aastar.io";
+    readonly superPaymaster: "https://superpaymaster.aastar.io";
+    readonly demo: "https://aastar.io/demo";
+    readonly github: "https://github.com/AAStarCommunity";
+    readonly discord: "https://discord.gg/aastar";
+    readonly twitter: "https://twitter.com/AAStarCommunity";
+};