@aastar/paymaster 0.16.7

package/dist/core/src/actions/registry.js

@@ -0,0 +1,667 @@
+import { RegistryABI } from '../abis/index.js';
+export const registryActions = (address) => (client) => ({
+    // Role Management
+    async registryConfigureRole({ roleId, config, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'configureRole',
+            args: [roleId, config],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryRegisterRole({ roleId, user, data, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'registerRole',
+            args: [roleId, user, data],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryRegisterRoleSelf({ roleId, data, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'registerRoleSelf',
+            args: [roleId, data],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryHasRole({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'hasRole',
+            args: [roleId, user]
+        });
+    },
+    async registryUnRegisterRole({ user, roleId, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'unregisterRole',
+            args: [user, roleId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryGetRoleConfig({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'getRoleConfig',
+            args: [roleId]
+        });
+    },
+    async registrySetRoleLockDuration({ roleId, duration, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setRoleLockDuration',
+            args: [roleId, duration],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registrySetRoleOwner({ roleId, newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setRoleOwner',
+            args: [roleId, newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryIsCommunityMember({ community, user }) {
+        const ROLE_ENDUSER = await this.registryROLE_ENDUSER();
+        return this.registryHasRole({ user, roleId: ROLE_ENDUSER });
+    },
+    // Credit & Reputation
+    async registryGlobalReputation({ user }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'globalReputation',
+            args: [user]
+        });
+    },
+    async registryBatchUpdateGlobalReputation({ users, scores, epoch, proof, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'batchUpdateGlobalReputation',
+            args: [users, scores, epoch, proof],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Blacklist Management
+    async registryUpdateOperatorBlacklist({ operator, users, statuses, proof, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'updateOperatorBlacklist',
+            args: [operator, users, statuses, proof],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryIsOperatorBlacklisted({ operator }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'isOperatorBlacklisted',
+            args: [operator]
+        });
+    },
+    // Contract References
+    async registrySetBLSValidator({ validator, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setBLSValidator',
+            args: [validator],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registrySetBLSAggregator({ aggregator, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setBLSAggregator',
+            args: [aggregator],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registrySetMySBT({ sbt, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setMySBT',
+            args: [sbt],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registrySetSuperPaymaster({ paymaster, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setSuperPaymaster',
+            args: [paymaster],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registrySetStaking({ staking, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setStaking',
+            args: [staking],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registrySetReputationSource({ source, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setReputationSource',
+            args: [source],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryBlsValidator() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'blsValidator',
+            args: []
+        });
+    },
+    async registryBlsAggregator() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'blsAggregator',
+            args: []
+        });
+    },
+    async registryMySBT() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'MYSBT',
+            args: []
+        });
+    },
+    async registrySuperPaymaster() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'SUPER_PAYMASTER',
+            args: []
+        });
+    },
+    async registryStaking() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'GTOKEN_STAKING',
+            args: []
+        });
+    },
+    async registryReputationSource() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'reputationSource',
+            args: []
+        });
+    },
+    // Admin
+    async registryTransferOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryOwner() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async registryRenounceOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // View Functions
+    async registryRoleConfigs({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleConfigs',
+            args: [roleId]
+        });
+    },
+    async registryRoleCounts({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleCounts',
+            args: [roleId]
+        });
+    },
+    // Alias: getRoleMemberCount maps to contract's getRoleUserCount
+    async registryGetRoleMemberCount({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'getRoleUserCount',
+            args: [roleId]
+        });
+    },
+    async registryRoleMembers({ roleId, index }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleMembers',
+            args: [roleId, index]
+        });
+    },
+    async registryUserRoles({ user, index }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'userRoles',
+            args: [user, index]
+        });
+    },
+    async registryUserRoleCount({ user }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'userRoleCount',
+            args: [user]
+        });
+    },
+    async registryLevelThresholds({ level }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'levelThresholds',
+            args: [level]
+        });
+    },
+    async registryExecutedProposals({ proposalId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'executedProposals',
+            args: [proposalId]
+        });
+    },
+    // Community lookup functions
+    async registryCommunityByName({ name }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'communityByName',
+            args: [name]
+        });
+    },
+    async registryCommunityByENS({ ensName }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'communityByENS',
+            args: [ensName]
+        });
+    },
+    async registryCommunityByNameV3({ name }) {
+        return this.registryCommunityByName({ name });
+    },
+    async registryCommunityByENSV3({ ensName }) {
+        return this.registryCommunityByENS({ ensName });
+    },
+    async registryProposedRoleNames({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'proposedRoleNames',
+            args: [roleId]
+        });
+    },
+    // Role Metadata & Members
+    async registryRoleLockDurations({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleLockDurations',
+            args: [roleId]
+        });
+    },
+    async registryRoleMetadata({ roleId, user }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleMetadata',
+            args: user ? [roleId, user] : [roleId]
+        });
+    },
+    async registryRoleStakes({ roleId, user }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleStakes',
+            args: [roleId, user]
+        });
+    },
+    async registryRoleSBTTokenIds({ roleId, user }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleSBTTokenIds',
+            args: [roleId, user]
+        });
+    },
+    async registryRoleOwners({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleOwners',
+            args: [roleId]
+        });
+    },
+    async registryRoleMemberIndex({ roleId, user }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'roleMemberIndex',
+            args: [roleId, user]
+        });
+    },
+    async registryGetRoleMembers({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'getRoleMembers',
+            args: [roleId]
+        });
+    },
+    async registryGetRoleUserCount({ roleId }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'getRoleUserCount',
+            args: [roleId]
+        });
+    },
+    async registryGetUserRoles({ user }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'getUserRoles',
+            args: [user]
+        });
+    },
+    async registryExitRole({ roleId, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'exitRole',
+            args: [roleId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryCalculateExitFee({ roleId, amount }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'calculateExitFee',
+            args: [roleId, amount]
+        });
+    },
+    async registryAddLevelThreshold({ threshold, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'addLevelThreshold',
+            args: [threshold],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registrySetLevelThreshold({ index, threshold, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setLevelThreshold',
+            args: [index, threshold],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryAccountToUser({ account: userAccount }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'accountToUser',
+            args: [userAccount]
+        });
+    },
+    // Credit & Tiers
+    async registryGetCreditLimit({ user }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'getCreditLimit',
+            args: [user]
+        });
+    },
+    async registrySetCreditTier({ level, limit, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'setCreditTier',
+            args: [level, limit],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryCreditTierConfig({ level }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'creditTierConfig',
+            args: [level]
+        });
+    },
+    // Role Admin
+    async registryAdminConfigureRole({ roleId, minStake, entryBurn, exitFeePercent, minExitFee, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'adminConfigureRole',
+            args: [roleId, minStake, entryBurn, exitFeePercent, minExitFee],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryCreateNewRole({ roleId, config, roleOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'createNewRole',
+            args: [roleId, config, roleOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registrySafeMintForRole({ roleId, user, data, account }) {
+        return client.writeContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'safeMintForRole',
+            args: [roleId, user, data],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async registryGetAccountCommunity({ account: userAccount }) {
+        // Check if user has COMMUNITY role
+        const COMMUNITY_ROLE_ID = '0x0000000000000000000000000000000000000000000000000000000000000002';
+        const hasRole = await client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'hasRole',
+            args: [userAccount, COMMUNITY_ROLE_ID]
+        });
+        if (!hasRole) {
+            return '0x0000000000000000000000000000000000000000';
+        }
+        // Get role data which contains the community token address
+        const roleData = await client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'getRoleData',
+            args: [userAccount, COMMUNITY_ROLE_ID]
+        });
+        // Parse community token from role data (first 20 bytes after removing 0x)
+        if (!roleData || roleData === '0x') {
+            return '0x0000000000000000000000000000000000000000';
+        }
+        // Community token is at bytes 0-19 of roleData
+        const tokenAddress = ('0x' + roleData.slice(2, 42));
+        return tokenAddress;
+    },
+    // Constants (Role IDs)
+    async registryROLE_COMMUNITY() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'ROLE_COMMUNITY',
+            args: []
+        });
+    },
+    async registryROLE_ENDUSER() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'ROLE_ENDUSER',
+            args: []
+        });
+    },
+    async registryROLE_PAYMASTER_SUPER() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'ROLE_PAYMASTER_SUPER',
+            args: []
+        });
+    },
+    async registryROLE_PAYMASTER_AOA() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'ROLE_PAYMASTER_AOA',
+            args: []
+        });
+    },
+    async registryROLE_DVT() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'ROLE_DVT',
+            args: []
+        });
+    },
+    async registryROLE_KMS() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'ROLE_KMS',
+            args: []
+        });
+    },
+    async registryROLE_ANODE() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'ROLE_ANODE',
+            args: []
+        });
+    },
+    async registryGTOKEN_STAKING() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'GTOKEN_STAKING',
+            args: []
+        });
+    },
+    async registryMYSBT() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'MYSBT',
+            args: []
+        });
+    },
+    async registrySUPER_PAYMASTER() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'SUPER_PAYMASTER',
+            args: []
+        });
+    },
+    async registryIsReputationSource({ source }) {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'isReputationSource',
+            args: [source]
+        });
+    },
+    async registryLastReputationEpoch() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'lastReputationEpoch',
+            args: []
+        });
+    },
+    // Version
+    async registryVersion() {
+        return client.readContract({
+            address,
+            abi: RegistryABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});