@aastar/dapp 0.16.7

package/dist/core/src/roles.js

@@ -0,0 +1,211 @@
+/**
+ * Role constants and utilities for AAstar SDK
+ * @remarks
+ * All role hashes and configurations match exactly with Registry.sol v3.0.0
+ *
+ * **Source**: /contracts/src/core/Registry.sol
+ */
+import { keccak256, toHex } from 'viem';
+// ========== Role Hash Constants (from Registry.sol lines 32-38) ==========
+/**
+ * Default Admin Role (OpenZeppelin AccessControl)
+ * @remarks
+ * - **Description**: Highest privilege, can grant/revoke all roles
+ * - **Permission**: Protocol governance only
+ * - **Source**: OpenZeppelin AccessControl DEFAULT_ADMIN_ROLE
+ */
+export const DEFAULT_ADMIN_ROLE = '0x0000000000000000000000000000000000000000000000000000000000000000';
+/**
+ * Community Role
+ * @remarks
+ * - **Description**: Community administrator, can issue xPNTs, configure SBT rules
+ * - **Permission**: Community-level governance
+ * - **Requirement**: minStake: 30 GT, entryBurn: 3 GT (line 99)
+ * - **Exit Fee**: 5% (500 basis points), min 1 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 32: ROLE_COMMUNITY = keccak256("COMMUNITY")
+ */
+export const ROLE_COMMUNITY = keccak256(toHex('COMMUNITY'));
+/**
+ * End User Role
+ * @remarks
+ * - **Description**: Community member, can participate and use gasless transactions
+ * - **Permission**: Basic user level
+ * - **Requirement**: minStake: 0.3 GT, entryBurn: 0.05 GT (line 100)
+ * - **Additional Requirement**: Must hold MySBT from community
+ * - **Exit Fee**: 10% (1000 basis points), min 0.05 GT
+ * - **Lock Duration**: 7 days
+ * - **Source**: Registry.sol line 33: ROLE_ENDUSER = keccak256("ENDUSER")
+ */
+export const ROLE_ENDUSER = keccak256(toHex('ENDUSER'));
+/**
+ * Paymaster AOA Role (Account Ownership Authentication)
+ * @remarks
+ * - **Description**: Basic Paymaster node operator with account-based auth
+ * - **Permission**: Infrastructure operator
+ * - **Requirement**: minStake: 30 GT, entryBurn: 3 GT (line 92)
+ * - **Exit Fee**: 10% (1000 basis points), min 1 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 34: ROLE_PAYMASTER_AOA = keccak256("PAYMASTER_AOA")
+ */
+export const ROLE_PAYMASTER_AOA = keccak256(toHex('PAYMASTER_AOA'));
+/**
+ * Paymaster Super Role
+ * @remarks
+ * - **Description**: Advanced Paymaster operator, can use SuperPaymaster with aPNTs collateral
+ * - **Permission**: Infrastructure operator (higher tier)
+ * - **Requirement**: minStake: 50 GT, entryBurn: 5 GT (line 93)
+ * - **Additional Requirement**: aPNTs collateral in SuperPaymaster contract
+ * - **Exit Fee**: 10% (1000 basis points), min 2 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 35: ROLE_PAYMASTER_SUPER = keccak256("PAYMASTER_SUPER")
+ */
+export const ROLE_PAYMASTER_SUPER = keccak256(toHex('PAYMASTER_SUPER'));
+/**
+ * DVT Role (Distributed Validator Technology)
+ * @remarks
+ * - **Description**: DVT node operator for consensus validation
+ * - **Permission**: Infrastructure operator
+ * - **Requirement**: minStake: 30 GT, entryBurn: 3 GT (line 94)
+ * - **Exit Fee**: 10% (1000 basis points), min 1 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 36: ROLE_DVT = keccak256("DVT")
+ */
+export const ROLE_DVT = keccak256(toHex('DVT'));
+/**
+ * ANODE Role (Anonymous Node)
+ * @remarks
+ * - **Description**: Anonymous infrastructure node operator
+ * - **Permission**: Infrastructure operator
+ * - **Requirement**: minStake: 20 GT, entryBurn: 2 GT (line 95)
+ * - **Exit Fee**: 10% (1000 basis points), min 1 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 37: ROLE_ANODE = keccak256("ANODE")
+ */
+export const ROLE_ANODE = keccak256(toHex('ANODE'));
+/**
+ * KMS Role (Key Management Service)
+ * @remarks
+ * - **Description**: KMS operator for secure key storage and management
+ * - **Permission**: Infrastructure operator (highest stake)
+ * - **Requirement**: minStake: 100 GT, entryBurn: 10 GT (line 98)
+ * - **Exit Fee**: 10% (1000 basis points), min 5 GT
+ * - **Lock Duration**: 30 days
+ * - **Source**: Registry.sol line 38: ROLE_KMS = keccak256("KMS")
+ */
+export const ROLE_KMS = keccak256(toHex('KMS'));
+// ========== Role Name Mapping ==========
+export const ROLE_NAMES = {
+    [DEFAULT_ADMIN_ROLE]: 'Default Admin',
+    [ROLE_COMMUNITY]: 'Community Admin',
+    [ROLE_ENDUSER]: 'End User',
+    [ROLE_PAYMASTER_AOA]: 'Paymaster (AOA)',
+    [ROLE_PAYMASTER_SUPER]: 'Paymaster (Super)',
+    [ROLE_DVT]: 'DVT Operator',
+    [ROLE_ANODE]: 'Anonymous Node',
+    [ROLE_KMS]: 'KMS Operator'
+};
+/**
+ * Get human-readable role name
+ */
+export function getRoleName(roleHash) {
+    return ROLE_NAMES[roleHash] || 'Unknown Role';
+}
+/**
+ * Role permission levels (for UI sorting/filtering)
+ */
+export var RolePermissionLevel;
+(function (RolePermissionLevel) {
+    RolePermissionLevel[RolePermissionLevel["PROTOCOL"] = 100] = "PROTOCOL";
+    RolePermissionLevel[RolePermissionLevel["KMS"] = 80] = "KMS";
+    RolePermissionLevel[RolePermissionLevel["OPERATOR"] = 50] = "OPERATOR";
+    RolePermissionLevel[RolePermissionLevel["COMMUNITY"] = 30] = "COMMUNITY";
+    RolePermissionLevel[RolePermissionLevel["USER"] = 10] = "USER"; // End Users
+})(RolePermissionLevel || (RolePermissionLevel = {}));
+export const ROLE_PERMISSION_LEVELS = {
+    [DEFAULT_ADMIN_ROLE]: RolePermissionLevel.PROTOCOL,
+    [ROLE_KMS]: RolePermissionLevel.KMS,
+    [ROLE_PAYMASTER_SUPER]: RolePermissionLevel.OPERATOR,
+    [ROLE_PAYMASTER_AOA]: RolePermissionLevel.OPERATOR,
+    [ROLE_DVT]: RolePermissionLevel.OPERATOR,
+    [ROLE_ANODE]: RolePermissionLevel.OPERATOR,
+    [ROLE_COMMUNITY]: RolePermissionLevel.COMMUNITY,
+    [ROLE_ENDUSER]: RolePermissionLevel.USER
+};
+/**
+ * Exact stake requirements from Registry.sol constructor (lines 92-100)
+ * @remarks
+ * **Warning**: These are initial values, always query contract for current configuration
+ */
+export const INITIAL_ROLE_STAKES = {
+    [ROLE_PAYMASTER_AOA]: {
+        minStake: '30 GT',
+        entryBurn: '3 GT',
+        exitFeePercent: '10%',
+        minExitFee: '1 GT',
+        lockDuration: '30 days',
+        line: 92
+    },
+    [ROLE_PAYMASTER_SUPER]: {
+        minStake: '50 GT',
+        entryBurn: '5 GT',
+        exitFeePercent: '10%',
+        minExitFee: '2 GT',
+        lockDuration: '30 days',
+        additionalRequirement: 'aPNTs collateral in SuperPaymaster',
+        line: 93
+    },
+    [ROLE_DVT]: {
+        minStake: '30 GT',
+        entryBurn: '3 GT',
+        exitFeePercent: '10%',
+        minExitFee: '1 GT',
+        lockDuration: '30 days',
+        line: 94
+    },
+    [ROLE_ANODE]: {
+        minStake: '20 GT',
+        entryBurn: '2 GT',
+        exitFeePercent: '10%',
+        minExitFee: '1 GT',
+        lockDuration: '30 days',
+        line: 95
+    },
+    [ROLE_KMS]: {
+        minStake: '100 GT',
+        entryBurn: '10 GT',
+        exitFeePercent: '10%',
+        minExitFee: '5 GT',
+        lockDuration: '30 days',
+        line: 98
+    },
+    [ROLE_COMMUNITY]: {
+        minStake: '30 GT',
+        entryBurn: '3 GT',
+        exitFeePercent: '5%',
+        minExitFee: '1 GT',
+        lockDuration: '30 days',
+        line: 99
+    },
+    [ROLE_ENDUSER]: {
+        minStake: '0.3 GT',
+        entryBurn: '0.05 GT',
+        exitFeePercent: '10%',
+        minExitFee: '0.05 GT',
+        lockDuration: '7 days',
+        additionalRequirement: 'Must hold MySBT from community',
+        line: 100
+    }
+};
+/**
+ * All defined roles array (for iteration)
+ */
+export const ALL_ROLES = [
+    ROLE_COMMUNITY,
+    ROLE_ENDUSER,
+    ROLE_PAYMASTER_AOA,
+    ROLE_PAYMASTER_SUPER,
+    ROLE_DVT,
+    ROLE_ANODE,
+    ROLE_KMS
+];

package/dist/core/src/utils/validation.d.ts

@@ -0,0 +1,24 @@
+export declare class AAStarValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validates an Ethereum address.
+ * Throws AAStarValidationError if invalid.
+ */
+export declare function validateAddress(address: string, fieldName?: string): `0x${string}`;
+/**
+ * Validates a BigInt amount.
+ * @param amount The value to check
+ * @param fieldName Name for error messages
+ * @param min Minimum value (default 0n)
+ * @param max Maximum value (optional)
+ */
+export declare function validateAmount(amount: bigint, fieldName?: string, min?: bigint, max?: bigint): bigint;
+/**
+ * Validates a UINT128 value (Common in Paymaster Data).
+ */
+export declare function validateUint128(value: bigint, fieldName?: string): bigint;
+/**
+ * Validates a Hex string.
+ */
+export declare function validateHex(value: string, fieldName?: string): `0x${string}`;

package/dist/core/src/utils/validation.js

@@ -0,0 +1,56 @@
+import { isAddress, getAddress } from 'viem';
+export class AAStarValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AAStarValidationError';
+    }
+}
+/**
+ * Validates an Ethereum address.
+ * Throws AAStarValidationError if invalid.
+ */
+export function validateAddress(address, fieldName = 'Address') {
+    if (!address) {
+        throw new AAStarValidationError(`${fieldName} is required.`);
+    }
+    if (!isAddress(address)) {
+        throw new AAStarValidationError(`${fieldName} must be a valid Ethereum address. Got: ${address}`);
+    }
+    return getAddress(address); // Returns checksummed address
+}
+/**
+ * Validates a BigInt amount.
+ * @param amount The value to check
+ * @param fieldName Name for error messages
+ * @param min Minimum value (default 0n)
+ * @param max Maximum value (optional)
+ */
+export function validateAmount(amount, fieldName = 'Amount', min = 0n, max) {
+    if (amount < min) {
+        throw new AAStarValidationError(`${fieldName} must be >= ${min}. Got: ${amount}`);
+    }
+    if (max !== undefined && amount > max) {
+        throw new AAStarValidationError(`${fieldName} must be <= ${max}. Got: ${amount}`);
+    }
+    return amount;
+}
+/**
+ * Validates a UINT128 value (Common in Paymaster Data).
+ */
+export function validateUint128(value, fieldName = 'Value') {
+    const MAX_UINT128 = (1n << 128n) - 1n;
+    return validateAmount(value, fieldName, 0n, MAX_UINT128);
+}
+/**
+ * Validates a Hex string.
+ */
+export function validateHex(value, fieldName = 'Hex') {
+    if (!value.startsWith('0x')) {
+        throw new AAStarValidationError(`${fieldName} must start with 0x. Got: ${value}`);
+    }
+    const hexRegex = /^0x[0-9a-fA-F]*$/;
+    if (!hexRegex.test(value)) {
+        throw new AAStarValidationError(`${fieldName} must be a valid hex string.`);
+    }
+    return value;
+}

package/dist/dapp/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ui/index.js';
+export * from './ui/hooks/useCreditScore.js';
+export * from './ui/hooks/useSuperPaymaster.js';

package/dist/dapp/src/index.js

@@ -0,0 +1,3 @@
+export * from './ui/index.js';
+export * from './ui/hooks/useCreditScore.js';
+export * from './ui/hooks/useSuperPaymaster.js';

package/dist/dapp/src/ui/components/EvaluationPanel.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type PaymasterConfig } from '@aastar/paymaster';
+import { type Chain, type Address } from 'viem';
+type EvaluationPanelProps = {
+    paymasterConfig: PaymasterConfig;
+    userAddress: Address;
+    chain: Chain;
+    registryAddress: Address;
+};
+export declare const EvaluationPanel: React.FC<EvaluationPanelProps>;
+export {};

package/dist/dapp/src/ui/components/EvaluationPanel.js

@@ -0,0 +1,37 @@
+import React from 'react';
+import { useCreditScore } from '../hooks/useCreditScore';
+export const EvaluationPanel = ({ paymasterConfig, userAddress, chain, registryAddress }) => {
+    const { creditLimit, loading } = useCreditScore({
+        chain,
+        userAddress,
+        registryAddress
+    });
+    return (React.createElement("div", { style: { padding: '10px', border: '1px solid #ccc', borderRadius: '4px', maxWidth: '300px' } },
+        React.createElement("h3", null, "SuperPaymaster Debug"),
+        React.createElement("div", { style: { fontSize: '12px' } },
+            React.createElement("p", null,
+                React.createElement("strong", null, "Status:"),
+                " ",
+                loading ? 'Loading...' : 'Ready'),
+            React.createElement("p", null,
+                React.createElement("strong", null, "User:"),
+                " ",
+                userAddress.slice(0, 6),
+                "...",
+                userAddress.slice(-4)),
+            React.createElement("p", null,
+                React.createElement("strong", null, "Credit Limit:"),
+                " ",
+                creditLimit ? creditLimit.toString() : '0'),
+            React.createElement("hr", null),
+            React.createElement("p", null,
+                React.createElement("strong", null, "Paymaster:"),
+                " ",
+                paymasterConfig.paymasterAddress.slice(0, 6),
+                "..."),
+            React.createElement("p", null,
+                React.createElement("strong", null, "Operator:"),
+                " ",
+                paymasterConfig.operator.slice(0, 6),
+                "..."))));
+};

package/dist/dapp/src/ui/hooks/useCreditScore.d.ts

@@ -0,0 +1,13 @@
+import { type Address, type Chain, type Transport } from 'viem';
+type UseCreditScoreConfig = {
+    chain: Chain;
+    rpcUrl?: string;
+    registryAddress: Address;
+    userAddress: Address;
+    transport?: Transport;
+};
+export declare function useCreditScore({ chain, rpcUrl, registryAddress, userAddress }: UseCreditScoreConfig): {
+    creditLimit: bigint | null;
+    loading: boolean;
+};
+export {};

package/dist/dapp/src/ui/hooks/useCreditScore.js

@@ -0,0 +1,32 @@
+import { useState, useEffect } from 'react';
+import { createAAStarPublicClient, RegistryABI } from '@aastar/core';
+export function useCreditScore({ chain, rpcUrl, registryAddress, userAddress }) {
+    const [creditLimit, setCreditLimit] = useState(null);
+    const [loading, setLoading] = useState(false);
+    useEffect(() => {
+        if (!registryAddress || !userAddress || !rpcUrl)
+            return;
+        const fetchCredit = async () => {
+            setLoading(true);
+            try {
+                const client = createAAStarPublicClient(rpcUrl, chain);
+                const limit = await client.readContract({
+                    address: registryAddress,
+                    abi: RegistryABI,
+                    functionName: 'getCreditLimit',
+                    args: [userAddress]
+                });
+                setCreditLimit(limit);
+            }
+            catch (e) {
+                console.error("Failed to fetch credit limit:", e);
+                setCreditLimit(0n);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        fetchCredit();
+    }, [chain, rpcUrl, registryAddress, userAddress]);
+    return { creditLimit, loading };
+}

package/dist/dapp/src/ui/hooks/useSuperPaymaster.d.ts

@@ -0,0 +1,8 @@
+import { type PaymasterConfig } from '@aastar/paymaster';
+type UseSuperPaymasterResult = {
+    generatePaymasterAndData: (userOp: any) => Promise<string>;
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useSuperPaymaster(config: PaymasterConfig): UseSuperPaymasterResult;
+export {};

package/dist/dapp/src/ui/hooks/useSuperPaymaster.js

@@ -0,0 +1,23 @@
+import { useState, useCallback } from 'react';
+import { getSuperPaymasterMiddleware } from '@aastar/paymaster';
+export function useSuperPaymaster(config) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const generatePaymasterAndData = useCallback(async (userOp) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const middleware = getSuperPaymasterMiddleware(config);
+            const result = await middleware.sponsorUserOperation({ userOperation: userOp });
+            return result.paymasterAndData;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [config.paymasterAddress, config.operator, config.verificationGasLimit, config.postOpGasLimit]);
+    return { generatePaymasterAndData, isLoading, error };
+}

package/dist/dapp/src/ui/index.d.ts

@@ -0,0 +1,4 @@
+import { type Address, type WalletClient, type Hex } from 'viem';
+export declare class DVTClient {
+    static registerValidator(wallet: WalletClient, dvtAddr: Address, blsPublicKey: Hex): Promise<`0x${string}`>;
+}

package/dist/dapp/src/ui/index.js

@@ -0,0 +1,17 @@
+import { parseAbi } from 'viem';
+const DVT_ABI = parseAbi([
+    'function registerValidator(bytes)',
+    'function createProposal(address, uint8, string)',
+    'function signProposal(uint256, bytes)'
+]);
+export class DVTClient {
+    static async registerValidator(wallet, dvtAddr, blsPublicKey) {
+        return wallet.writeContract({
+            address: dvtAddr,
+            abi: DVT_ABI,
+            functionName: 'registerValidator',
+            args: [blsPublicKey],
+            chain: wallet.chain
+        });
+    }
+}

package/dist/paymaster/src/SuperPaymaster/index.d.ts

@@ -0,0 +1,44 @@
+import { type Address } from 'viem';
+export type PaymasterConfig = {
+    paymasterAddress: Address;
+    operator: Address;
+    maxRate?: bigint;
+    verificationGasLimit?: bigint;
+    postOpGasLimit?: bigint;
+};
+/**
+ * Constructs the middleware for SuperPaymaster.
+ * Returns the `paymasterAndData` hex string.
+ */
+export declare function getSuperPaymasterMiddleware(config: PaymasterConfig): {
+    sponsorUserOperation: (args: {
+        userOperation: any;
+    }) => Promise<{
+        paymasterAndData: `0x${string}`;
+        verificationGasLimit: bigint;
+        preVerificationGas: any;
+    }>;
+};
+/**
+ * Enhanced eligibility check for SuperPaymaster V3.
+ * Validates that user has sufficient credit with the given operator.
+ */
+export declare function checkEligibility(client: any, paymaster: Address, user: Address, operator: Address): Promise<{
+    eligible: boolean;
+    credit?: bigint;
+    token?: Address;
+}>;
+/**
+ * Admin Client for SuperPaymaster V3
+ */
+export declare class SuperPaymasterAdminClient {
+    private client;
+    private paymasterAddress;
+    constructor(client: any, paymasterAddress: Address);
+    getOperator(operator: Address): Promise<any>;
+    static configureOperator(wallet: any, paymaster: Address, token: Address, treasury: Address, exchangeRate: bigint): Promise<any>;
+    static setOperatorPaused(wallet: any, paymaster: Address, operator: Address, paused: boolean): Promise<any>;
+    static updateReputation(wallet: any, paymaster: Address, operator: Address, score: bigint): Promise<any>;
+    static setAPNTsToken(wallet: any, paymaster: Address, token: Address): Promise<any>;
+    static setXPNTsFactory(wallet: any, paymaster: Address, factory: Address): Promise<any>;
+}

package/dist/paymaster/src/SuperPaymaster/index.js

@@ -0,0 +1,133 @@
+import { concat, pad, toHex } from 'viem';
+import { SuperPaymasterABI as SUPERPAYMASTER_ABI } from '@aastar/core';
+const DEFAULT_VERIFICATION_GAS = 160000n;
+const DEFAULT_POSTOP_GAS = 10000n;
+/**
+ * Constructs the middleware for SuperPaymaster.
+ * Returns the `paymasterAndData` hex string.
+ */
+export function getSuperPaymasterMiddleware(config) {
+    return {
+        sponsorUserOperation: async (args) => {
+            const verGas = config.verificationGasLimit ?? DEFAULT_VERIFICATION_GAS;
+            const postGas = config.postOpGasLimit ?? DEFAULT_POSTOP_GAS;
+            const maxRate = config.maxRate ?? 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
+            // V3.2.1 Layout: [Paymaster(20)] [VerGas(16)] [PostOpGas(16)] [Operator(20)] [MaxRate(32)]
+            // Offset 72 starts MaxRate.
+            const paymasterAndData = concat([
+                config.paymasterAddress,
+                pad(toHex(verGas), { size: 16 }),
+                pad(toHex(postGas), { size: 16 }),
+                config.operator,
+                pad(toHex(maxRate), { size: 32 })
+            ]);
+            return {
+                paymasterAndData,
+                verificationGasLimit: verGas,
+                preVerificationGas: args.userOperation.preVerificationGas,
+            };
+        }
+    };
+}
+/**
+ * Enhanced eligibility check for SuperPaymaster V3.
+ * Validates that user has sufficient credit with the given operator.
+ */
+export async function checkEligibility(client, paymaster, user, operator) {
+    try {
+        // 1. Fetch operator's configured token
+        const operatorData = await client.readContract({
+            address: paymaster,
+            abi: SUPERPAYMASTER_ABI,
+            functionName: 'operators',
+            args: [operator]
+        });
+        // operatorData structure: [token, treasury, isConfigured, isPaused, exchangeRate, ...]
+        const token = operatorData[0];
+        const isConfigured = operatorData[2];
+        const isPaused = operatorData[3];
+        if (!isConfigured || isPaused) {
+            return { eligible: false };
+        }
+        // 2. Check available credit
+        const credit = await client.readContract({
+            address: paymaster,
+            abi: SUPERPAYMASTER_ABI,
+            functionName: 'getAvailableCredit',
+            args: [user, token]
+        });
+        return {
+            eligible: credit > 0n,
+            credit: credit,
+            token
+        };
+    }
+    catch (e) {
+        console.warn('Eligibility check failed:', e);
+        return { eligible: false };
+    }
+}
+/**
+ * Admin Client for SuperPaymaster V3
+ */
+export class SuperPaymasterAdminClient {
+    client;
+    paymasterAddress;
+    constructor(client, paymasterAddress) {
+        this.client = client;
+        this.paymasterAddress = paymasterAddress;
+    }
+    async getOperator(operator) {
+        return this.client.readContract({
+            address: this.paymasterAddress,
+            abi: SUPERPAYMASTER_ABI,
+            functionName: 'operators',
+            args: [operator]
+        });
+    }
+    static async configureOperator(wallet, paymaster, token, treasury, exchangeRate) {
+        return wallet.writeContract({
+            address: paymaster,
+            abi: SUPERPAYMASTER_ABI,
+            functionName: 'configureOperator',
+            args: [token, treasury, exchangeRate],
+            chain: wallet.chain
+        });
+    }
+    static async setOperatorPaused(wallet, paymaster, operator, paused) {
+        return wallet.writeContract({
+            address: paymaster,
+            abi: SUPERPAYMASTER_ABI,
+            functionName: 'setOperatorPaused',
+            args: [operator, paused],
+            chain: wallet.chain
+        });
+    }
+    static async updateReputation(wallet, paymaster, operator, score) {
+        return wallet.writeContract({
+            address: paymaster,
+            abi: SUPERPAYMASTER_ABI,
+            functionName: 'updateReputation',
+            args: [operator, score],
+            chain: wallet.chain
+        });
+    }
+    static async setAPNTsToken(wallet, paymaster, token) {
+        return wallet.writeContract({
+            address: paymaster,
+            abi: SUPERPAYMASTER_ABI,
+            functionName: 'setAPNTsToken',
+            args: [token],
+            chain: wallet.chain
+        });
+    }
+    static async setXPNTsFactory(wallet, paymaster, factory) {
+        return wallet.writeContract({
+            address: paymaster,
+            abi: SUPERPAYMASTER_ABI,
+            functionName: 'setXPNTsFactory',
+            args: [factory],
+            chain: wallet.chain
+        });
+    }
+}