@aastar/sdk 0.14.3 → 0.16.6

package/packages/core/src/actions/reputation.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { type Address, type PublicClient, type WalletClient, type Account, type Hex } from 'viem';
+import { reputationActions } from './reputation.js';
+
+describe('Reputation Actions', () => {
+    const mockReputationAddress: Address = '0x1234567890123456789012345678901234567890';
+    let mockPublicClient: Partial<PublicClient>;
+    let mockWalletClient: Partial<WalletClient>;
+    let mockAccount: Account;
+
+    const MOCK_USER: Address = '0x2222222222222222222222222222222222222222';
+    const MOCK_COMMUNITY: Address = '0x3333333333333333333333333333333333333333';
+    const MOCK_RULE_ID = '0xabcd1234567890123456789012345678901234567890abcd1234567890123456' as `0x${string}`;
+
+    beforeEach(() => {
+        mockAccount = {
+            address: '0x1111111111111111111111111111111111111111' as Address,
+            type: 'json-rpc'
+        } as Account;
+
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+
+    describe('Rule Configuration', () => {
+        it('should get reputation rule', async () => {
+            const mockRule = { weight: 50, active: true };
+            (mockPublicClient.readContract as any).mockResolvedValue(mockRule);
+
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient as PublicClient);
+            const rule = await actions.getReputationRule({ ruleId: MOCK_RULE_ID });
+
+            expect(rule).toEqual(mockRule);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    functionName: 'getReputationRule',
+                    args: [MOCK_RULE_ID],
+                })
+            );
+        });
+
+        it('should check if rule is active', async () => {
+            (mockPublicClient.readContract as any).mockResolvedValue(true);
+
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient as PublicClient);
+            const active = await actions.isRuleActive({ ruleId: MOCK_RULE_ID });
+
+            expect(active).toBe(true);
+        });
+
+        it('should get active rules for community', async () => {
+            const mockRules = [MOCK_RULE_ID];
+            (mockPublicClient.readContract as any).mockResolvedValue(mockRules);
+
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient as PublicClient);
+            const rules = await actions.getActiveRules({ community: MOCK_COMMUNITY });
+
+            expect(rules).toEqual(mockRules);
+        });
+
+        it('should get rule count', async () => {
+            (mockPublicClient.readContract as any).mockResolvedValue(10n);
+
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient as PublicClient);
+            const count = await actions.getRuleCount();
+
+            expect(count).toBe(10n);
+        });
+    });
+
+    describe('Score Computation', () => {
+        it('should compute score', async () => {
+            (mockPublicClient.readContract as any).mockResolvedValue(850n);
+
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient as PublicClient);
+            const score = await actions.computeScore({ user: MOCK_USER, community: MOCK_COMMUNITY });
+
+            expect(score).toBe(850n);
+        });
+
+        it('should get user score', async () => {
+            (mockPublicClient.readContract as any).mockResolvedValue(900n);
+
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient as PublicClient);
+            const score = await actions.getUserScore({ user: MOCK_USER });
+
+            expect(score).toBe(900n);
+        });
+
+        it('should get community score', async () => {
+            (mockPublicClient.readContract as any).mockResolvedValue(750n);
+
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient as PublicClient);
+            const score = await actions.getCommunityScore({ community: MOCK_COMMUNITY });
+
+            expect(score).toBe(750n);
+        });
+
+        it('should get community reputations mapping', async () => {
+            (mockPublicClient.readContract as any).mockResolvedValue(800n);
+
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient as PublicClient);
+            const reputation = await actions.communityReputations({ community: MOCK_COMMUNITY, user: MOCK_USER });
+
+            expect(reputation).toBe(800n);
+        });
+    });
+
+    describe('Write Operations', () => {
+        it('should set reputation rule', async () => {
+            const txHash = '0xabc...';
+            (mockWalletClient.writeContract as any).mockResolvedValue(txHash);
+
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient as WalletClient);
+            const result = await actions.setReputationRule({
+                ruleId: MOCK_RULE_ID,
+                rule: { weight: 50, active: true } as any,
+                account: mockAccount
+            });
+
+            expect(result).toBe(txHash);
+        });
+
+        it('should enable rule', async () => {
+            const txHash = '0xdef...';
+            (mockWalletClient.writeContract as any).mockResolvedValue(txHash);
+
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient as WalletClient);
+            const result = await actions.enableRule({ ruleId: MOCK_RULE_ID, account: mockAccount });
+
+            expect(result).toBe(txHash);
+        });
+
+        it('should disable rule', async () => {
+            const txHash = '0xghi...';
+            (mockWalletClient.writeContract as any).mockResolvedValue(txHash);
+
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient as WalletClient);
+            const result = await actions.disableRule({ ruleId: MOCK_RULE_ID, account: mockAccount });
+
+            expect(result).toBe(txHash);
+        });
+
+        it('should batch update scores', async () => {
+            const txHash = '0xjkl...';
+            (mockWalletClient.writeContract as any).mockResolvedValue(txHash);
+
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient as WalletClient);
+            const result = await actions.batchUpdateScores({
+                users: [MOCK_USER],
+                scores: [100n],
+                account: mockAccount
+            });
+
+            expect(result).toBe(txHash);
+        });
+    });
+
+    describe('Sync Operations', () => {
+        it('should batch sync to registry', async () => {
+            const txHash = '0xmno...';
+            (mockWalletClient.writeContract as any).mockResolvedValue(txHash);
+
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient as WalletClient);
+            const result = await actions.batchSyncToRegistry({
+                users: [MOCK_USER],
+                account: mockAccount
+            });
+
+            expect(result).toBe(txHash);
+        });
+
+        it('should sync to registry with proof', async () => {
+            const txHash = '0xpqr...';
+            (mockWalletClient.writeContract as any).mockResolvedValue(txHash);
+
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient as WalletClient);
+            const result = await actions.syncToRegistry({
+                user: MOCK_USER,
+                communities: [MOCK_COMMUNITY],
+                ruleIds: [[MOCK_RULE_ID]],
+                activities: [[100n]],
+                epoch: 1n,
+                proof: '0x' as `0x${string}`,
+                account: mockAccount
+            });
+
+            expect(result).toBe(txHash);
+        });
+    });
+
+    describe('Admin Functions', () => {
+        it('should set registry', async () => {
+            const txHash = '0xstu...';
+            (mockWalletClient.writeContract as any).mockResolvedValue(txHash);
+
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient as WalletClient);
+            const result = await actions.setRegistry({
+                registry: '0x8888888888888888888888888888888888888888' as Address,
+                account: mockAccount
+            });
+
+            expect(result).toBe(txHash);
+        });
+
+        it('should set entropy factor', async () => {
+            const txHash = '0xvwx...';
+            (mockWalletClient.writeContract as any).mockResolvedValue(txHash);
+
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient as WalletClient);
+            const result = await actions.setEntropyFactor({
+                factor: 100n,
+                account: mockAccount
+            });
+
+            expect(result).toBe(txHash);
+        });
+    });
+});

package/packages/core/src/actions/reputation.ts

@@ -2,6 +2,29 @@ import { type Address, type PublicClient, type WalletClient, type Hex, type Hash
 import { ReputationSystemABI } from '../abis/index.js';
 
 export type ReputationActions = {
+    // 规则配置
+    setReputationRule: (args: { ruleId: Hex, rule: any, account?: Account | Address }) => Promise<Hash>;
+    getReputationRule: (args: { ruleId: Hex }) => Promise<any>;
+    enableRule: (args: { ruleId: Hex, account?: Account | Address }) => Promise<Hash>;
+    disableRule: (args: { ruleId: Hex, account?: Account | Address }) => Promise<Hash>;
+    isRuleActive: (args: { ruleId: Hex }) => Promise<boolean>;
+    getActiveRules: (args: { community: Address }) => Promise<Hex[]>;
+    getRuleCount: () => Promise<bigint>;
+    
+    // 积分计算
+    computeScore: (args: { user: Address, community: Address }) => Promise<bigint>;
+    getUserScore: (args: { user: Address }) => Promise<bigint>;
+    getCommunityScore: (args: { community: Address }) => Promise<bigint>;
+    communityReputations: (args: { community: Address, user: Address }) => Promise<bigint>; // Public mapping getter
+    
+    // Missing Critical Actions
+    setRule: (args: { ruleId: Hex, rule: any, account?: Account | Address }) => Promise<Hash>; // Alias for setReputationRule
+    calculateReputation: (args: { user: Address, community: Address }) => Promise<bigint>; // Alias for computeScore or specific calculation
+    nftCollectionBoost: (args: { collection: Address }) => Promise<bigint>;
+    
+    // 批量操作
+    batchUpdateScores: (args: { users: Address[], scores: bigint[], account?: Account | Address }) => Promise<Hash>;
+    batchSyncToRegistry: (args: { users: Address[], account?: Account | Address }) => Promise<Hash>;
     syncToRegistry: (args: { 
         user: Address, 
         communities: Address[], 
@@ -11,9 +34,195 @@ export type ReputationActions = {
         proof: Hex, 
         account?: Account | Address 
     }) => Promise<Hash>;
+    
+    // Admin & Config
+    setRegistry: (args: { registry: Address, account?: Account | Address }) => Promise<Hash>;
+    setEntropyFactor: (args: { factor: bigint, account?: Account | Address }) => Promise<Hash>;
+    getEntropyFactor: () => Promise<bigint>;
+    
+    // Constants
+    REGISTRY: () => Promise<Address>;
+    
+    // Ownership
+    reputationOwner: () => Promise<Address>;
+    transferReputationOwnership: (args: { newOwner: Address, account?: Account | Address }) => Promise<Hash>;
+    renounceReputationOwnership: (args: { account?: Account | Address }) => Promise<Hash>;
+    
+    // Admin & Config (Missing)
+    setCommunityReputation: (args: { community: Address, reputation: bigint, account?: Account | Address }) => Promise<Hash>;
+    updateNFTHoldStart: (args: { user: Address, collection: Address, start: bigint, account?: Account | Address }) => Promise<Hash>;
+    
+    // Views (Missing)
+    communityRules: (args: { community: Address, ruleId: Hex }) => Promise<boolean>;
+    defaultRule: () => Promise<Hex>;
+    entropyFactors: (args: { factorId: bigint }) => Promise<bigint>;
+    nftHoldStart: (args: { user: Address, collection: Address }) => Promise<bigint>;
+    boostedCollections: (args: { collection: Address }) => Promise<bigint>;
+    communityActiveRules: (args: { community: Address, ruleId: Hex }) => Promise<boolean>;
+    getReputationBreakdown: (args: { user: Address, community: Address }) => Promise<any>;
+    setNFTBoost: (args: { collection: Address, boost: bigint, account?: Account | Address }) => Promise<Hash>;
+    
+    // Version
+    reputationVersion: () => Promise<string>;
 };
 
 export const reputationActions = (address: Address) => (client: PublicClient | WalletClient): ReputationActions => ({
+    // 规则配置
+    async setReputationRule({ ruleId, rule, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setReputationRule',
+            args: [ruleId, rule],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async getReputationRule({ ruleId }) {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getReputationRule',
+            args: [ruleId]
+        });
+    },
+
+    async enableRule({ ruleId, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'enableRule',
+            args: [ruleId],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async disableRule({ ruleId, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'disableRule',
+            args: [ruleId],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async isRuleActive({ ruleId }) {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'isRuleActive',
+            args: [ruleId]
+        }) as Promise<boolean>;
+    },
+
+    async getActiveRules({ community }) {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getActiveRules',
+            args: [community]
+        }) as Promise<Hex[]>;
+    },
+
+    async getRuleCount() {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getRuleCount',
+            args: []
+        }) as Promise<bigint>;
+    },
+
+    // 积分计算
+    async computeScore({ user, community }) {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'computeScore',
+            args: [user, community]
+        }) as Promise<bigint>;
+    },
+
+    async getUserScore({ user }) {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getUserScore',
+            args: [user]
+        }) as Promise<bigint>;
+    },
+
+    async getCommunityScore({ community }) {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getCommunityScore',
+            args: [community]
+        }) as Promise<bigint>;
+    },
+
+    // Public mapping getter
+    async communityReputations({ community, user }) {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'communityReputations',
+            args: [community, user]
+        }) as Promise<bigint>;
+    },
+
+    // Missing Critical Actions
+    async setRule(args) {
+        return this.setReputationRule(args);
+    },
+
+    async calculateReputation(args) {
+        // Assuming calculateReputation calls computeScore or check if dedicated function exists
+        // Report said calculateReputation matches ABI.
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'calculateReputation', // If this fails, it means calculateReputation is NOT in ABI and tool was confused? But report said it IS in ABI.
+            args: [args.user, args.community]
+        }) as Promise<bigint>;
+    },
+
+    async nftCollectionBoost({ collection }) {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'nftCollectionBoost',
+            args: [collection]
+        }) as Promise<bigint>;
+    },
+
+    // 批量操作
+    async batchUpdateScores({ users, scores, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'batchUpdateScores',
+            args: [users, scores],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async batchSyncToRegistry({ users, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'batchSyncToRegistry',
+            args: [users],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
     async syncToRegistry({ user, communities, ruleIds, activities, epoch, proof, account }) {
         return (client as any).writeContract({
             address,
@@ -23,5 +232,147 @@ export const reputationActions = (address: Address) => (client: PublicClient | W
             account: account as any,
             chain: (client as any).chain
         });
+    },
+
+    // Admin & Config
+    async setRegistry({ registry, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async setEntropyFactor({ factor, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setEntropyFactor',
+            args: [factor],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async getEntropyFactor() {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getEntropyFactor',
+            args: []
+        }) as Promise<bigint>;
+    },
+
+    // Constants
+    async REGISTRY() {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'REGISTRY',
+            args: []
+        }) as Promise<Address>;
+    },
+
+    // Ownership
+    async reputationOwner() {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'owner',
+            args: []
+        }) as Promise<Address>;
+    },
+
+    async renounceReputationOwnership({ account }: { account?: Account | Address } = {}) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async transferReputationOwnership({ newOwner, account }: { newOwner: Address, account?: Account | Address }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async setCommunityReputation({ community, reputation, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setCommunityReputation',
+            args: [community, reputation],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    async updateNFTHoldStart({ user, collection, start, account }) {
+        return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'updateNFTHoldStart',
+            args: [user, collection, start],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    // Views
+    async communityRules({ community, ruleId }) {
+        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'communityRules', args: [community, ruleId] }) as Promise<boolean>;
+    },
+    async defaultRule() {
+        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'defaultRule', args: [] }) as Promise<Hex>;
+    },
+    async entropyFactors({ factorId }) {
+        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'entropyFactors', args: [factorId] }) as Promise<bigint>;
+    },
+    async nftHoldStart({ user, collection }) {
+        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'nftHoldStart', args: [user, collection] }) as Promise<bigint>;
+    },
+    async boostedCollections({ collection }) {
+        return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'boostedCollections', args: [collection] }) as Promise<bigint>;
+    },
+
+    async communityActiveRules({ community, ruleId }) {
+         return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'communityActiveRules', args: [community, ruleId] }) as Promise<boolean>;
+    },
+
+    async getReputationBreakdown({ user, community }) {
+         return (client as PublicClient).readContract({ address, abi: ReputationSystemABI, functionName: 'getReputationBreakdown', args: [user, community] });
+    },
+
+    async setNFTBoost({ collection, boost, account }) {
+          return (client as any).writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setNFTBoost',
+            args: [collection, boost],
+            account: account as any,
+            chain: (client as any).chain
+        });
+    },
+
+    // Version
+    async reputationVersion() {
+        return (client as PublicClient).readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'version',
+            args: []
+        }) as Promise<string>;
     }
 });