@aastar/identity 0.16.7

package/dist/core/src/actions/reputation.d.ts

@@ -0,0 +1,129 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+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>;
+    setRule: (args: {
+        ruleId: Hex;
+        rule: any;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    calculateReputation: (args: {
+        user: Address;
+        community: Address;
+    }) => Promise<bigint>;
+    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[];
+        ruleIds: Hex[][];
+        activities: bigint[][];
+        epoch: bigint;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setRegistry: (args: {
+        registry: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setEntropyFactor: (args: {
+        factor: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getEntropyFactor: () => Promise<bigint>;
+    REGISTRY: () => Promise<Address>;
+    reputationOwner: () => Promise<Address>;
+    transferReputationOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    renounceReputationOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setCommunityReputation: (args: {
+        community: Address;
+        reputation: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updateNFTHoldStart: (args: {
+        user: Address;
+        collection: Address;
+        start: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    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>;
+    reputationVersion: () => Promise<string>;
+};
+export declare const reputationActions: (address: Address) => (client: PublicClient | WalletClient) => ReputationActions;

package/dist/core/src/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/core/src/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;