@aastar/dapp 0.16.7 → 0.16.11

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

@@ -1,129 +0,0 @@
-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

@@ -1,281 +0,0 @@
-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

@@ -1,191 +0,0 @@
-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;