@aastar/core 0.16.7

package/dist/actions/reputation.js

@@ -0,0 +1,281 @@
+import { ReputationSystemABI } from '../abis/index.js';
+export const reputationActions = (address) => (client) => ({
+    // 规则配置
+    async setReputationRule({ ruleId, rule, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setReputationRule',
+            args: [ruleId, rule],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getReputationRule({ ruleId }) {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getReputationRule',
+            args: [ruleId]
+        });
+    },
+    async enableRule({ ruleId, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'enableRule',
+            args: [ruleId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async disableRule({ ruleId, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'disableRule',
+            args: [ruleId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async isRuleActive({ ruleId }) {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'isRuleActive',
+            args: [ruleId]
+        });
+    },
+    async getActiveRules({ community }) {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getActiveRules',
+            args: [community]
+        });
+    },
+    async getRuleCount() {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getRuleCount',
+            args: []
+        });
+    },
+    // 积分计算
+    async computeScore({ user, community }) {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'computeScore',
+            args: [user, community]
+        });
+    },
+    async getUserScore({ user }) {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getUserScore',
+            args: [user]
+        });
+    },
+    async getCommunityScore({ community }) {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getCommunityScore',
+            args: [community]
+        });
+    },
+    // Public mapping getter
+    async communityReputations({ community, user }) {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'communityReputations',
+            args: [community, user]
+        });
+    },
+    // 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.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]
+        });
+    },
+    async nftCollectionBoost({ collection }) {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'nftCollectionBoost',
+            args: [collection]
+        });
+    },
+    // 批量操作
+    async batchUpdateScores({ users, scores, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'batchUpdateScores',
+            args: [users, scores],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async batchSyncToRegistry({ users, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'batchSyncToRegistry',
+            args: [users],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async syncToRegistry({ user, communities, ruleIds, activities, epoch, proof, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'syncToRegistry',
+            args: [user, communities, ruleIds, activities, epoch, proof],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Admin & Config
+    async setRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setEntropyFactor({ factor, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setEntropyFactor',
+            args: [factor],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getEntropyFactor() {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'getEntropyFactor',
+            args: []
+        });
+    },
+    // Constants
+    async REGISTRY() {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    // Ownership
+    async reputationOwner() {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async renounceReputationOwnership({ account } = {}) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async transferReputationOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setCommunityReputation({ community, reputation, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setCommunityReputation',
+            args: [community, reputation],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async updateNFTHoldStart({ user, collection, start, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'updateNFTHoldStart',
+            args: [user, collection, start],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Views
+    async communityRules({ community, ruleId }) {
+        return client.readContract({ address, abi: ReputationSystemABI, functionName: 'communityRules', args: [community, ruleId] });
+    },
+    async defaultRule() {
+        return client.readContract({ address, abi: ReputationSystemABI, functionName: 'defaultRule', args: [] });
+    },
+    async entropyFactors({ factorId }) {
+        return client.readContract({ address, abi: ReputationSystemABI, functionName: 'entropyFactors', args: [factorId] });
+    },
+    async nftHoldStart({ user, collection }) {
+        return client.readContract({ address, abi: ReputationSystemABI, functionName: 'nftHoldStart', args: [user, collection] });
+    },
+    async boostedCollections({ collection }) {
+        return client.readContract({ address, abi: ReputationSystemABI, functionName: 'boostedCollections', args: [collection] });
+    },
+    async communityActiveRules({ community, ruleId }) {
+        return client.readContract({ address, abi: ReputationSystemABI, functionName: 'communityActiveRules', args: [community, ruleId] });
+    },
+    async getReputationBreakdown({ user, community }) {
+        return client.readContract({ address, abi: ReputationSystemABI, functionName: 'getReputationBreakdown', args: [user, community] });
+    },
+    async setNFTBoost({ collection, boost, account }) {
+        return client.writeContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'setNFTBoost',
+            args: [collection, boost],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Version
+    async reputationVersion() {
+        return client.readContract({
+            address,
+            abi: ReputationSystemABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});

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

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

package/dist/actions/reputation.test.js

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { reputationActions } from './reputation.js';
+describe('Reputation Actions', () => {
+    const mockReputationAddress = '0x1234567890123456789012345678901234567890';
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_USER = '0x2222222222222222222222222222222222222222';
+    const MOCK_COMMUNITY = '0x3333333333333333333333333333333333333333';
+    const MOCK_RULE_ID = '0xabcd1234567890123456789012345678901234567890abcd1234567890123456';
+    beforeEach(() => {
+        mockAccount = {
+            address: '0x1111111111111111111111111111111111111111',
+            type: 'json-rpc'
+        };
+        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.mockResolvedValue(mockRule);
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient);
+            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.mockResolvedValue(true);
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient);
+            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.mockResolvedValue(mockRules);
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient);
+            const rules = await actions.getActiveRules({ community: MOCK_COMMUNITY });
+            expect(rules).toEqual(mockRules);
+        });
+        it('should get rule count', async () => {
+            mockPublicClient.readContract.mockResolvedValue(10n);
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient);
+            const count = await actions.getRuleCount();
+            expect(count).toBe(10n);
+        });
+    });
+    describe('Score Computation', () => {
+        it('should compute score', async () => {
+            mockPublicClient.readContract.mockResolvedValue(850n);
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient);
+            const score = await actions.computeScore({ user: MOCK_USER, community: MOCK_COMMUNITY });
+            expect(score).toBe(850n);
+        });
+        it('should get user score', async () => {
+            mockPublicClient.readContract.mockResolvedValue(900n);
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient);
+            const score = await actions.getUserScore({ user: MOCK_USER });
+            expect(score).toBe(900n);
+        });
+        it('should get community score', async () => {
+            mockPublicClient.readContract.mockResolvedValue(750n);
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient);
+            const score = await actions.getCommunityScore({ community: MOCK_COMMUNITY });
+            expect(score).toBe(750n);
+        });
+        it('should get community reputations mapping', async () => {
+            mockPublicClient.readContract.mockResolvedValue(800n);
+            const actions = reputationActions(mockReputationAddress)(mockPublicClient);
+            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.mockResolvedValue(txHash);
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient);
+            const result = await actions.setReputationRule({
+                ruleId: MOCK_RULE_ID,
+                rule: { weight: 50, active: true },
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should enable rule', async () => {
+            const txHash = '0xdef...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient);
+            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.mockResolvedValue(txHash);
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient);
+            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.mockResolvedValue(txHash);
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient);
+            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.mockResolvedValue(txHash);
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient);
+            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.mockResolvedValue(txHash);
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient);
+            const result = await actions.syncToRegistry({
+                user: MOCK_USER,
+                communities: [MOCK_COMMUNITY],
+                ruleIds: [[MOCK_RULE_ID]],
+                activities: [[100n]],
+                epoch: 1n,
+                proof: '0x',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+    });
+    describe('Admin Functions', () => {
+        it('should set registry', async () => {
+            const txHash = '0xstu...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient);
+            const result = await actions.setRegistry({
+                registry: '0x8888888888888888888888888888888888888888',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should set entropy factor', async () => {
+            const txHash = '0xvwx...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = reputationActions(mockReputationAddress)(mockWalletClient);
+            const result = await actions.setEntropyFactor({
+                factor: 100n,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+    });
+});

package/dist/actions/sbt.d.ts

@@ -0,0 +1,191 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type SBTActions = {
+    sbtSafeMintForRole: (args: {
+        roleId: Hex;
+        to: Address;
+        tokenURI: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtAirdropMint: (args: {
+        roleId: Hex;
+        to: Address;
+        tokenURI: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtMintForRole: (args: {
+        roleId: Hex;
+        to: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtGetUserSBT: (args: {
+        user: Address;
+        roleId: Hex;
+    }) => Promise<bigint>;
+    sbtGetSBTData: (args: {
+        tokenId: bigint;
+    }) => Promise<any>;
+    sbtGetCommunityMembership: (args: {
+        user: Address;
+        community: Address;
+    }) => Promise<bigint>;
+    sbtGetMemberships: (args: {
+        user: Address;
+    }) => Promise<any[]>;
+    sbtGetActiveMemberships: (args: {
+        user: Address;
+    }) => Promise<any[]>;
+    sbtVerifyCommunityMembership: (args: {
+        user: Address;
+        community: Address;
+    }) => Promise<boolean>;
+    sbtUserToSBT: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    sbtSbtData: (args: {
+        tokenId: bigint;
+    }) => Promise<any>;
+    sbtMembershipIndex: (args: {
+        user: Address;
+        index: bigint;
+    }) => Promise<any>;
+    sbtBalanceOf: (args: {
+        owner: Address;
+    }) => Promise<bigint>;
+    sbtOwnerOf: (args: {
+        tokenId: bigint;
+    }) => Promise<Address>;
+    sbtSafeTransferFrom: (args: {
+        from: Address;
+        to: Address;
+        tokenId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtTransferFrom: (args: {
+        from: Address;
+        to: Address;
+        tokenId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtApprove: (args: {
+        to: Address;
+        tokenId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtSetApprovalForAll: (args: {
+        operator: Address;
+        approved: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtGetApproved: (args: {
+        tokenId: bigint;
+    }) => Promise<Address>;
+    sbtIsApprovedForAll: (args: {
+        owner: Address;
+        operator: Address;
+    }) => Promise<boolean>;
+    sbtName: () => Promise<string>;
+    sbtSymbol: () => Promise<string>;
+    sbtTokenURI: (args: {
+        tokenId: bigint;
+    }) => Promise<string>;
+    sbtTotalSupply: () => Promise<bigint>;
+    sbtTokenByIndex: (args: {
+        index: bigint;
+    }) => Promise<bigint>;
+    sbtTokenOfOwnerByIndex: (args: {
+        owner: Address;
+        index: bigint;
+    }) => Promise<bigint>;
+    sbtSupportsInterface: (args: {
+        interfaceId: Hex;
+    }) => Promise<boolean>;
+    sbtNextTokenId: () => Promise<bigint>;
+    sbtMint: (args: {
+        to: Address;
+        tokenURI: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtBurn: (args: {
+        tokenId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtBurnSBT: (args: {
+        tokenId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtDeactivateAllMemberships: (args: {
+        user: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtSetBaseURI: (args: {
+        baseURI: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtLeaveCommunity: (args: {
+        community: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtDeactivateMembership: (args: {
+        tokenId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtRecordActivity: (args: {
+        user: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtLastActivityTime: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    sbtWeeklyActivity: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    sbtReputationCalculator: () => Promise<Address>;
+    sbtSetReputationCalculator: (args: {
+        calculator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtMintFee: () => Promise<bigint>;
+    sbtSetMintFee: (args: {
+        fee: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtMinLockAmount: () => Promise<bigint>;
+    sbtSetMinLockAmount: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtPause: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtUnpause: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtPaused: () => Promise<boolean>;
+    sbtDaoMultisig: () => Promise<Address>;
+    sbtSetDAOMultisig: (args: {
+        multisig: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtSetRegistry: (args: {
+        registry: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtSetSuperPaymaster: (args: {
+        paymaster: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtVersion: () => Promise<string>;
+    sbtREGISTRY: () => Promise<Address>;
+    sbtGTOKEN_STAKING: () => Promise<Address>;
+    sbtGTOKEN: () => Promise<Address>;
+    sbtSUPER_PAYMASTER: () => Promise<Address>;
+    sbtOwner: () => Promise<Address>;
+    sbtTransferSBTOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    sbtRenounceOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+};
+export declare const sbtActions: (address: Address) => (client: PublicClient | WalletClient) => SBTActions;