@aastar/sdk 0.20.8 → 0.21.0

package/dist/dapp.d.cts

@@ -0,0 +1,127 @@
+import { WalletClient, Address, Hex } from 'viem';
+import { P as PaymasterConfig } from './index-B6SfEQxo.cjs';
+
+declare class DVTClient {
+    static registerValidator(wallet: WalletClient, dvtAddr: Address, blsPublicKey: Hex): Promise<`0x${string}`>;
+}
+
+type UseCreditScoreConfig = {
+    chain: any;
+    rpcUrl?: string;
+    registryAddress: Address;
+    userAddress: Address;
+    transport?: any;
+};
+declare function useCreditScore({ chain, rpcUrl, registryAddress, userAddress }: UseCreditScoreConfig): {
+    creditLimit: bigint | null;
+    loading: boolean;
+};
+
+type UseSuperPaymasterResult = {
+    generatePaymasterAndData: (userOp: any) => Promise<string>;
+    isLoading: boolean;
+    error: Error | null;
+};
+declare function useSuperPaymaster(config: PaymasterConfig): UseSuperPaymasterResult;
+
+/**
+ * eip1193.ts — EIP-1193 compatible provider wrapping AirAccount M7.
+ *
+ * Intercepts eth_sendTransaction and converts it to an ERC-4337 v0.7
+ * PackedUserOperation submitted to the bundler via eth_sendUserOperation.
+ * All other JSON-RPC methods are forwarded to the public RPC.
+ */
+
+interface AirAccountProviderConfig {
+    /** EVM chain ID */
+    chainId: number;
+    /** Public JSON-RPC URL */
+    rpcUrl: string;
+    /** ERC-4337 bundler URL */
+    bundlerUrl: string;
+    /** EntryPoint v0.7 address (defaults to canonical) */
+    entryPoint?: Address;
+    /** The user's AirAccount smart contract address */
+    accountAddress: Address;
+    /**
+     * Signs the UserOp hash and returns a 65-byte hex signature.
+     * For passkey/ECDSA, format as M7 composite validator signature.
+     */
+    signer: (userOpHash: Hex) => Promise<Hex>;
+}
+/**
+ * AirAccountEIP1193Provider — drop-in EIP-1193 wallet backed by an AirAccount M7 smart account.
+ *
+ * Usage:
+ * ```ts
+ * const provider = new AirAccountEIP1193Provider({
+ *   chainId: 11155111,
+ *   rpcUrl: 'https://rpc.sepolia.org',
+ *   bundlerUrl: 'https://api.pimlico.io/v2/11155111/rpc?apikey=...',
+ *   accountAddress: '0x...',
+ *   signer: async (hash) => passkeySign(hash),
+ * });
+ * // Pass to wagmi, ethers.js BrowserProvider, or window.ethereum
+ * ```
+ */
+declare class AirAccountEIP1193Provider {
+    private readonly config;
+    private readonly client;
+    private readonly listeners;
+    constructor(config: AirAccountProviderConfig);
+    request({ method, params }: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string, listener: (...args: unknown[]) => void): this;
+    private _sendTransaction;
+    private _forwardToRpc;
+}
+
+/**
+ * eip6963.ts — EIP-6963 Multi Injected Provider Discovery for AirAccount.
+ *
+ * Announces AirAccount as an EIP-1193 wallet via the eip6963:announceProvider
+ * DOM event, enabling DApps to auto-discover it without relying on window.ethereum.
+ *
+ * Reference: https://eips.ethereum.org/EIPS/eip-6963
+ */
+
+interface EIP6963ProviderInfo {
+    /** Globally unique wallet identifier (UUID v4). Must not change across sessions. */
+    uuid: string;
+    /** Human-readable wallet name displayed in DApp UI */
+    name: string;
+    /** Wallet icon as a data URI (SVG or PNG, base64) */
+    icon: string;
+    /** Reverse-DNS identifier, e.g. "community.aastar.airaccount" */
+    rdns: string;
+}
+interface EIP6963ProviderDetail {
+    info: EIP6963ProviderInfo;
+    provider: AirAccountEIP1193Provider;
+}
+/**
+ * Announce AirAccount as an EIP-6963 wallet so DApps can auto-discover it.
+ *
+ * Call this once at app startup. Returns a cleanup function that removes the
+ * event listener when the wallet is no longer available.
+ *
+ * @example
+ * ```ts
+ * const provider = new AirAccountEIP1193Provider({ ... });
+ * const cleanup = announceAirAccount(provider);
+ * // later: cleanup() to stop announcing
+ * ```
+ */
+declare function announceAirAccount(provider: AirAccountEIP1193Provider, info?: Partial<EIP6963ProviderInfo>): () => void;
+/**
+ * Listen for EIP-6963 wallet announcements from other providers in the page.
+ * Useful for composing AirAccount with MetaMask fallback, etc.
+ *
+ * Returns a cleanup function to stop listening.
+ */
+declare function watchProviders(onProvider: (detail: EIP6963ProviderDetail) => void): () => void;
+
+export { AirAccountEIP1193Provider, type AirAccountProviderConfig, DVTClient, type EIP6963ProviderDetail, type EIP6963ProviderInfo, announceAirAccount, useCreditScore, useSuperPaymaster, watchProviders };

package/dist/dapp.js

@@ -1,6 +1,6 @@
-import { getSuperPaymasterMiddleware } from './chunk-MVEWJIPY.js';
-import { createAAStarPublicClient, RegistryABI } from './chunk-6QYXGMCR.js';
-import './chunk-G3UJC4EL.js';
+import { getSuperPaymasterMiddleware } from './chunk-RXPSL33E.js';
+import { createAAStarPublicClient, RegistryABI } from './chunk-M5WFKETT.js';
+import './chunk-UCLK6LTB.js';
 import './chunk-PZ5AY32C.js';
 import { parseAbi, createPublicClient, http, hashTypedData, hashMessage, hexToBytes, encodeFunctionData } from 'viem';
 import { useState, useEffect, useCallback } from 'react';

package/dist/doc-types-471vSmPO.d.cts

@@ -0,0 +1,16 @@
+import { PublicClient as PublicClient$1, Transport, Chain, Account, WalletClient as WalletClient$1 } from 'viem';
+
+/**
+ * Public Client Interface
+ * Standardized interface for reading from the blockchain.
+ */
+interface PublicClient extends PublicClient$1 {
+}
+/**
+ * Wallet Client Interface
+ * Standardized interface for interacting with Ethereum wallets and accounts.
+ */
+interface WalletClient<TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined, TAccount extends Account | undefined = Account | undefined> extends WalletClient$1<TTransport, TChain, TAccount> {
+}
+
+export type { PublicClient as P, WalletClient as W };

package/dist/enduser.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var chunk63JM67L7_cjs = require('./chunk-63JM67L7.cjs');
+var chunkDEUBKZH5_cjs = require('./chunk-DEUBKZH5.cjs');
+require('./chunk-CIEYY3A6.cjs');
+require('./chunk-MXJEULSE.cjs');
+require('./chunk-Q7SFCCGT.cjs');
+
+
+
+Object.defineProperty(exports, "CommunityClient", {
+  enumerable: true,
+  get: function () { return chunk63JM67L7_cjs.CommunityClient; }
+});
+Object.defineProperty(exports, "UserLifecycle", {
+  enumerable: true,
+  get: function () { return chunk63JM67L7_cjs.UserLifecycle; }
+});
+Object.defineProperty(exports, "UserClient", {
+  enumerable: true,
+  get: function () { return chunkDEUBKZH5_cjs.UserClient; }
+});
+//# sourceMappingURL=enduser.cjs.map
+//# sourceMappingURL=enduser.cjs.map

package/dist/enduser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"enduser.cjs"}

package/dist/enduser.d.cts

@@ -0,0 +1,261 @@
+import { Address, Hash, Hex } from 'viem';
+import { C as ClientConfig, a as BaseClient, T as TransactionOptions } from './BaseClient-CkBhQ1ou.cjs';
+import './doc-types-471vSmPO.cjs';
+
+interface UserClientConfig extends ClientConfig {
+    accountAddress: Address;
+    sbtAddress?: Address;
+    entryPointAddress?: Address;
+    superPaymasterAddress?: Address;
+    gTokenStakingAddress?: Address;
+    registryAddress?: Address;
+    gTokenAddress?: Address;
+    bundlerClient?: any;
+}
+declare class UserClient extends BaseClient {
+    accountAddress: Address;
+    sbtAddress?: Address;
+    entryPointAddress?: Address;
+    gTokenStakingAddress?: Address;
+    registryAddress?: Address;
+    gTokenAddress?: Address;
+    bundlerClient?: any;
+    constructor(config: UserClientConfig);
+    /**
+     * Deploy a new Smart Account (Supports multiple factory types)
+     * Static helper to facilitate onboarding before instantiating the UserClient.
+     *
+     * @param client - WalletClient to sign the deployment transaction
+     * @param params - Deployment parameters
+     * @returns Object containing the deployed account address and transaction hash
+     */
+    static deployAccount(client: any, params: {
+        owner: Address;
+        salt?: bigint;
+        factoryAddress?: Address;
+        publicClient?: any;
+        accountType?: 'simple' | 'kernel' | 'safe' | string;
+        customAbi?: any;
+    }): Promise<{
+        accountAddress: Address;
+        hash: Hash;
+    }>;
+    /**
+     * Get the nonce of the account from EntryPoint (more reliable for 4337)
+     */
+    getNonce(key?: bigint): Promise<bigint>;
+    /**
+     * Get the owner of the AA account
+     */
+    getOwner(): Promise<Address>;
+    /**
+     * Execute a transaction from the AA account
+     */
+    execute(target: Address, value: bigint, data: Hex, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Execute a batch of transactions
+     */
+    executeBatch(targets: Address[], values: bigint[], datas: Hex[], options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get user's SBT balance
+     */
+    getSBTBalance(): Promise<bigint>;
+    mintSBT(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    transferToken(token: Address, to: Address, amount: bigint, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get Token Balance
+     */
+    getTokenBalance(token: Address): Promise<bigint>;
+    stakeForRole(roleId: Hex, amount: bigint, options?: TransactionOptions): Promise<Hash>;
+    unstakeFromRole(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get staked balance for a specific role
+     */
+    getStakedBalance(roleId: Hex): Promise<bigint>;
+    exitRole(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    leaveCommunity(community: Address, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Register as EndUser (One-click: Approve + Register)
+     * Handles GToken approval to Staking contract and Role registration.
+     */
+    registerAsEndUser(communityAddress: Address, stakeAmount: bigint, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Execute a transaction with Gasless Sponsorship
+     */
+    executeGasless(params: {
+        target: Address;
+        value: bigint;
+        data: Hex;
+        paymaster: Address;
+        paymasterType: 'V4' | 'Super';
+        operator?: Address;
+        maxRate?: bigint;
+    }, options?: TransactionOptions): Promise<Hash>;
+}
+
+interface CommunityClientConfig extends ClientConfig {
+    sbtAddress?: Address;
+    factoryAddress?: Address;
+    reputationAddress?: Address;
+}
+interface CreateCommunityParams {
+    name: string;
+    tokenSymbol: string;
+    ensName?: string;
+    description?: string;
+}
+interface CommunityInfo {
+    address: Address;
+}
+/**
+ * Client for Community Managers (`ROLE_COMMUNITY`)
+ */
+declare class CommunityClient extends BaseClient {
+    sbtAddress?: Address;
+    factoryAddress?: Address;
+    reputationAddress?: Address;
+    constructor(config: CommunityClientConfig);
+    /**
+     * Create a new Community Token (xPNTs) and register it.
+     * Note: In the current architecture, creating a community often involves:
+     * 1. Registering the ROLE_COMMUNITY on Registry (if not exists) -> usually manual or self-register
+     * 2. Deploying a Token (xPNTs) via Factory
+     * 3. Linking the Token to the Community in Registry
+     */
+    createCommunityToken(params: CreateCommunityParams, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get Community Details (Decodes Role Metadata)
+     * @param communityAddress - The address of the community manager (defaults to self)
+     */
+    getCommunityInfo(communityAddress?: Address): Promise<{
+        name: string;
+        ensName: string;
+        website: string;
+        description: string;
+        logoURI: string;
+        stakeAmount: bigint;
+    }>;
+    /**
+     * Register self as a Community Manager.
+     * This method handles all necessary steps:
+     * 1. Checks and approves GToken to GTokenStaking
+     * 2. Encodes CommunityRoleData with provided parameters
+     * 3. Calls registerRoleSelf on Registry
+     *
+     * @param params Community registration parameters
+     * @param options Transaction options
+     * @returns Transaction hash
+     */
+    registerAsCommunity(params: {
+        name: string;
+        ensName?: string;
+        website?: string;
+        description?: string;
+        logoURI?: string;
+        stakeAmount?: bigint;
+    }, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * One-click Setup: Register Community + Deploy Token
+     * Orchestrates the complete community initialization flow.
+     */
+    setupCommunity(params: {
+        name: string;
+        tokenName: string;
+        tokenSymbol: string;
+        description?: string;
+        logoURI?: string;
+        website?: string;
+        stakeAmount?: bigint;
+    }, options?: TransactionOptions): Promise<{
+        tokenAddress: Address;
+        hashes: Hash[];
+    }>;
+    /**
+     * Airdrop SBTs to users to make them members
+     */
+    airdropSBT(users: Address[], roleId: bigint, options?: TransactionOptions): Promise<Hash>;
+    setReputationRule(ruleId: bigint, ruleConfig: any, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Revoke membership (Burn SBT)
+     */
+    revokeMembership(userAddr: Address, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Transfer ownership of the Community Token
+     */
+    transferCommunityTokenOwnership(tokenAddress: Address, newOwner: Address, options?: TransactionOptions): Promise<Hash>;
+}
+
+interface GaslessConfig {
+    paymasterUrl: string;
+    policy?: 'CREDIT' | 'TOKEN' | 'SPONSORED';
+}
+interface UserLifecycleConfig extends ClientConfig {
+    accountAddress: Address;
+    registryAddress: Address;
+    sbtAddress: Address;
+    gTokenAddress: Address;
+    gTokenStakingAddress: Address;
+    entryPointAddress: Address;
+    gasless?: GaslessConfig;
+}
+interface OnboardResult {
+    success: boolean;
+    sbtId?: bigint;
+    txHash?: Hash;
+}
+interface ReputationData {
+    score: bigint;
+    level: bigint;
+    creditLimit: bigint;
+}
+/**
+ * UserLifecycle - L3 Pattern
+ *
+ * Responsibilities:
+ * 1. Managing the complete lifecycle of an End User (Onboard -> Operate -> Exit)
+ * 2. Providing a unified interface for Gasless operations
+ * 3. Abstracting underlying contract interactions via L2 Actions
+ */
+declare class UserLifecycle extends BaseClient {
+    accountAddress: Address;
+    registryAddress: Address;
+    sbtAddress: Address;
+    gTokenAddress: Address;
+    gTokenStakingAddress: Address;
+    entryPointAddress: Address;
+    gaslessConfig?: GaslessConfig;
+    config: UserLifecycleConfig;
+    constructor(config: UserLifecycleConfig);
+    /**
+     * Check if user is eligible to join a community
+     * @param community Address of the community
+     */
+    checkEligibility(community: Address): Promise<boolean>;
+    /**
+     * One-click Onboarding: Approve -> Stake -> Register -> Mint SBT
+     * @param community Address of the community to join
+     * @param stakeAmount Amount of GToken to stake (default 0.4 GT)
+     */
+    onboard(community: Address, stakeAmount?: bigint): Promise<OnboardResult>;
+    /**
+     * Enable or update Gasless configuration
+     */
+    enableGasless(config: GaslessConfig): Promise<void>;
+    /**
+     * Execute a transaction effectively using Gasless configuration if available
+     */
+    executeGaslessTx(params: {
+        target: Address;
+        value: bigint;
+        data: Hex;
+        operator?: Address;
+    }): Promise<Hash>;
+    claimSBT(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    getMyReputation(): Promise<ReputationData>;
+    getCreditLimit(): Promise<bigint>;
+    leaveCommunity(community: Address, options?: TransactionOptions): Promise<Hash>;
+    exitRole(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+    unstakeAll(roleId: Hex, options?: TransactionOptions): Promise<Hash>;
+}
+
+export { CommunityClient, type CommunityClientConfig, type CommunityInfo, type CreateCommunityParams, type GaslessConfig, type OnboardResult, type ReputationData, UserClient, type UserClientConfig, UserLifecycle, type UserLifecycleConfig };

package/dist/enduser.js

@@ -1,7 +1,7 @@
-export { CommunityClient, UserLifecycle } from './chunk-TENYCMJ3.js';
-export { UserClient } from './chunk-PAABYXS6.js';
-import './chunk-6QYXGMCR.js';
-import './chunk-G3UJC4EL.js';
+export { CommunityClient, UserLifecycle } from './chunk-DF4WVR2H.js';
+export { UserClient } from './chunk-MCALA6WM.js';
+import './chunk-M5WFKETT.js';
+import './chunk-UCLK6LTB.js';
 import './chunk-PZ5AY32C.js';
 //# sourceMappingURL=enduser.js.map
 //# sourceMappingURL=enduser.js.map

package/dist/identity.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var chunkWR4OZUXR_cjs = require('./chunk-WR4OZUXR.cjs');
+require('./chunk-CIEYY3A6.cjs');
+require('./chunk-MXJEULSE.cjs');
+require('./chunk-Q7SFCCGT.cjs');
+
+
+
+Object.defineProperty(exports, "ReputationClient", {
+  enumerable: true,
+  get: function () { return chunkWR4OZUXR_cjs.ReputationClient; }
+});
+Object.defineProperty(exports, "checkMySBT", {
+  enumerable: true,
+  get: function () { return chunkWR4OZUXR_cjs.checkMySBT; }
+});
+Object.defineProperty(exports, "getMySBTId", {
+  enumerable: true,
+  get: function () { return chunkWR4OZUXR_cjs.getMySBTId; }
+});
+//# sourceMappingURL=identity.cjs.map
+//# sourceMappingURL=identity.cjs.map

package/dist/identity.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"identity.cjs"}

package/dist/identity.d.cts

@@ -0,0 +1,81 @@
+import { Address, Hash } from 'viem';
+import { P as PublicClient, W as WalletClient } from './doc-types-471vSmPO.cjs';
+
+/**
+ * Check if user holds MySBT token (identity verification).
+ *
+ * Does NOT swallow read errors: `balanceOf` returns 0 for a non-holder, so any
+ * thrown error is an RPC/transport/contract failure — masking it as
+ * `{ hasSBT: false }` would turn a transient RPC blip into a false "no SBT" and
+ * wrongly fail eligibility checks. The error propagates so the caller can retry
+ * or surface "couldn't determine" rather than "no SBT".
+ */
+declare function checkMySBT(client: any, sbtAddress: Address, user: Address): Promise<{
+    hasSBT: boolean;
+    balance: bigint;
+}>;
+/**
+ * Fetch MySBT token ID for a specific user.
+ * MySBT exposes `getUserSBT(address) -> uint256` (alias of the `userToSBT`
+ * mapping), which returns the user's tokenId or 0 when they hold no SBT.
+ *
+ * Returns the tokenId, or `null` ONLY for the genuine "no SBT" sentinel (id == 0).
+ * Read errors are NOT swallowed (see {@link checkMySBT}): a transient RPC failure
+ * must not be reported as "no SBT" (a false negative for eligibility). The error
+ * propagates to the caller.
+ */
+declare function getMySBTId(client: any, sbtAddress: Address, user: Address): Promise<bigint | null>;
+
+declare class ReputationClient {
+    private client;
+    private reputationAddress;
+    /** @internal */
+    private walletClient?;
+    /**
+     * Initialize ReputationClient
+     * @param client The public client for queries
+     * @param reputationAddress The address of the reputation system contract
+     * @param walletClient Optional wallet client for write operations
+     */
+    constructor(client: PublicClient, reputationAddress: Address, walletClient?: WalletClient);
+    /**
+     * Compute reputation score for a user
+     */
+    computeScore(user: Address, communities: Address[], ruleIds: `0x${string}`[][], activities: bigint[][]): Promise<bigint>;
+    /**
+     * Get global reputation score for a user
+     * @param user User address
+     * @returns Reputation score
+     */
+    getGlobalReputation(user: Address): Promise<number>;
+    /**
+     * Get credit limit based on reputation
+     * @param user User address
+     * @returns Credit limit in wei (Mock logic closely tied to Reputation)
+     */
+    getCreditLimit(user: Address): Promise<bigint>;
+    /**
+     * Get reputation score breakdown
+     * @param user User address
+     * @returns Detailed reputation breakdown (Mock implementation awaiting contract V4)
+     */
+    getReputationBreakdown(user: Address): Promise<{
+        baseScore: number;
+        stakingBonus: number;
+        activityBonus: number;
+        penaltyDeduction: number;
+        total: number;
+    }>;
+    /**
+     * Submit reputation proof (off-chain data to on-chain)
+     * @param params Proof parameters
+     * @returns Transaction hash
+     */
+    submitReputationProof(params: {
+        proofType: 'github' | 'twitter' | 'on-chain-activity';
+        proofData: string;
+        signature: Hash;
+    }): Promise<Hash>;
+}
+
+export { ReputationClient, checkMySBT, getMySBTId };

package/dist/identity.js

@@ -1,6 +1,6 @@
-export { ReputationClient, checkMySBT, getMySBTId } from './chunk-PKCHRXFR.js';
-import './chunk-6QYXGMCR.js';
-import './chunk-G3UJC4EL.js';
+export { ReputationClient, checkMySBT, getMySBTId } from './chunk-KZERVPUR.js';
+import './chunk-M5WFKETT.js';
+import './chunk-UCLK6LTB.js';
 import './chunk-PZ5AY32C.js';
 //# sourceMappingURL=identity.js.map
 //# sourceMappingURL=identity.js.map

package/dist/index-B6SfEQxo.d.cts

@@ -0,0 +1,47 @@
+import { Address } from 'viem';
+
+type PaymasterConfig = {
+    paymasterAddress: Address;
+    operator: Address;
+    maxRate?: bigint;
+    verificationGasLimit?: bigint;
+    postOpGasLimit?: bigint;
+};
+/**
+ * Constructs the middleware for SuperPaymaster.
+ * Returns the `paymasterAndData` hex string.
+ */
+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.
+ */
+declare function checkEligibility(client: any, paymaster: Address, user: Address, operator: Address): Promise<{
+    eligible: boolean;
+    credit?: bigint;
+    token?: Address;
+}>;
+/**
+ * Admin Client for SuperPaymaster V3
+ */
+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): 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>;
+}
+
+export { type PaymasterConfig as P, SuperPaymasterAdminClient as S, checkEligibility as c, getSuperPaymasterMiddleware as g };