@aastar/operator 0.16.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AAStar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__tests__/PaymasterOperatorClient.test.ts

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PaymasterOperatorClient } from '../src/PaymasterOperatorClient';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from './mocks/client';
+import { parseEther } from 'viem';
+
+// Define mocks
+const mocks = vi.hoisted(() => {
+  const mockRegistry = { ROLE_COMMUNITY: vi.fn(), ROLE_PAYMASTER_SUPER: vi.fn(), ROLE_PAYMASTER_AOA: vi.fn(), hasRole: vi.fn(), registerRoleSelf: vi.fn() };
+  const mockToken = { allowance: vi.fn(), approve: vi.fn() };
+  const mockSuperPaymaster = { APNTS_TOKEN: vi.fn(), deposit: vi.fn(), configureOperator: vi.fn(), operators: vi.fn() };
+  const mockPaymasterFactory = { deployPaymaster: vi.fn(), getPaymaster: vi.fn() };
+  const mockPaymaster = { setTokenPrice: vi.fn(), tokenPrices: vi.fn(), depositFor: vi.fn() };
+
+  return {
+    mockRegistry,
+    mockToken,
+    mockSuperPaymaster,
+    mockPaymasterFactory,
+    mockPaymaster,
+    // Factory Functions
+    mockRegistryActions: vi.fn(() => () => mockRegistry),
+    mockTokenActions: vi.fn(() => () => mockToken),
+    mockSuperPaymasterActions: vi.fn(() => () => mockSuperPaymaster),
+    mockPaymasterFactoryActions: vi.fn(() => () => mockPaymasterFactory),
+    mockPaymasterActions: vi.fn(() => () => mockPaymaster),
+  };
+});
+
+vi.mock('@aastar/core', async () => {
+  const actual = await vi.importActual('@aastar/core');
+  return {
+    ...actual,
+    registryActions: mocks.mockRegistryActions,
+    tokenActions: mocks.mockTokenActions,
+    superPaymasterActions: mocks.mockSuperPaymasterActions,
+    paymasterFactoryActions: mocks.mockPaymasterFactoryActions,
+    paymasterActions: mocks.mockPaymasterActions,
+  };
+});
+
+vi.mock('viem', async () => {
+    const actual = await vi.importActual('viem');
+    return {
+        ...actual,
+        encodeFunctionData: vi.fn().mockReturnValue('0xInitData'),
+        // encodeAbiParameters: vi.fn().mockReturnValue('0xAbiData') // Use real implementation if possible, or mock carefully
+    };
+});
+
+describe('PaymasterOperatorClient', () => {
+  let client: PaymasterOperatorClient;
+  const mockPublicClient = createMockPublicClient();
+  const mockWalletClient = createMockWalletClient();
+
+  const config = {
+    params: { chainId: 11155111, rpcUrl: 'https://rpc.sepolia.org' },
+    services: {},
+    client: mockWalletClient as any,
+    superPaymasterAddress: '0x1111111111111111111111111111111111111111' as `0x${string}`,
+    tokenAddress: '0x2222222222222222222222222222222222222222' as `0x${string}`,
+    registryAddress: '0x3333333333333333333333333333333333333333' as `0x${string}`,
+    gTokenAddress: '0x4444444444444444444444444444444444444444' as `0x${string}`,
+    gTokenStakingAddress: '0x5555555555555555555555555555555555555555' as `0x${string}`,
+    paymasterFactoryAddress: '0x6666666666666666666666666666666666666666' as `0x${string}`,
+    entryPointAddress: '0x0000000071727De22E5E9d8BAf0edAc6f37da032' as `0x${string}`,
+  };
+
+  beforeEach(() => {
+    resetMocks();
+    vi.clearAllMocks();
+
+    // Default Mocks
+    mocks.mockRegistry.ROLE_COMMUNITY.mockResolvedValue('0x1111111111111111111111111111111111111111111111111111111111111111');
+    mocks.mockRegistry.ROLE_PAYMASTER_SUPER.mockResolvedValue('0x2222222222222222222222222222222222222222222222222222222222222222');
+    mocks.mockRegistry.ROLE_PAYMASTER_AOA.mockResolvedValue('0x3333333333333333333333333333333333333333333333333333333333333333');
+    mocks.mockRegistry.hasRole.mockResolvedValue(true); // Default has prerequisite
+    mocks.mockRegistry.registerRoleSelf.mockResolvedValue('0xTxHash');
+    mocks.mockToken.allowance.mockResolvedValue(parseEther('1000'));
+    mocks.mockToken.approve.mockResolvedValue('0xTxHash');
+    mocks.mockSuperPaymaster.APNTS_TOKEN.mockResolvedValue('0xAPNTS');
+    mocks.mockSuperPaymaster.deposit.mockResolvedValue('0xTxHash');
+    mocks.mockSuperPaymaster.configureOperator.mockResolvedValue('0xTxHash');
+    mocks.mockSuperPaymaster.operators.mockResolvedValue({
+        aPNTsBalance: 0n,
+        xPNTsToken: '0x2222222222222222222222222222222222222222',
+        treasury: '0x3333333333333333333333333333333333333333',
+        exchangeRate: 150n,
+        isConfigured: true,
+        isPaused: false,
+        reputation: 100,
+        minTxInterval: 60,
+        totalSpent: 0n,
+        totalTxSponsored: 0n
+    });
+    mocks.mockPaymasterFactory.deployPaymaster.mockResolvedValue('0xTxHash');
+    mocks.mockPaymasterFactory.getPaymaster.mockResolvedValue('0x7777777777777777777777777777777777777777');
+    mocks.mockPaymaster.setTokenPrice.mockResolvedValue('0xTxHash');
+    mocks.mockPaymaster.tokenPrices.mockResolvedValue(100n);
+    mocks.mockPaymaster.depositFor.mockResolvedValue('0xTxHash');
+
+    client = new PaymasterOperatorClient(config);
+    (client as any).client = mockWalletClient;
+    (client as any).publicClient = mockPublicClient;
+  });
+
+  describe('Registration', () => {
+    it('registerAsSuperPaymasterOperator should verify roles and register', async () => {
+        mocks.mockRegistry.hasRole
+            .mockResolvedValueOnce(true) // Has Community
+            .mockResolvedValueOnce(false); // Does not have SuperRole yet
+
+        await client.registerAsSuperPaymasterOperator({ stakeAmount: 100n });
+
+        expect(mocks.mockRegistry.registerRoleSelf).toHaveBeenCalledWith(expect.objectContaining({
+            roleId: '0x2222222222222222222222222222222222222222222222222222222222222222'
+        }));
+    });
+
+    it('registerAsSuperPaymasterOperator should throw if no community role', async () => {
+        mocks.mockRegistry.hasRole.mockResolvedValue(false);
+        await expect(client.registerAsSuperPaymasterOperator()).rejects.toThrow('Must have ROLE_COMMUNITY');
+    });
+
+    it('registerAsSuperPaymasterOperator should approve if needed', async () => {
+        mocks.mockRegistry.hasRole
+             .mockResolvedValueOnce(true)
+             .mockResolvedValueOnce(false);
+        mocks.mockToken.allowance.mockResolvedValue(0n);
+
+        await client.registerAsSuperPaymasterOperator({ stakeAmount: 100n });
+        
+        expect(mocks.mockToken.approve).toHaveBeenCalled();
+    });
+
+    it('registerAsSuperPaymasterOperator should handle optional deposit', async () => {
+        mocks.mockRegistry.hasRole
+             .mockResolvedValueOnce(true)
+             .mockResolvedValueOnce(false);
+        
+        await client.registerAsSuperPaymasterOperator({ depositAmount: 50n });
+        
+        expect(mocks.mockSuperPaymaster.deposit).toHaveBeenCalled();
+    });
+  });
+
+  describe('Deployment', () => {
+      it('deployAndRegisterPaymasterV4 should deploy and register', async () => {
+        // Mock role checks: Community exists, AOA doesn't
+        mocks.mockRegistry.hasRole.mockImplementation(async ({ roleId }: any) => {
+            if (roleId === '0x1111111111111111111111111111111111111111111111111111111111111111') return true;
+            if (roleId === '0x3333333333333333333333333333333333333333333333333333333333333333') return false;
+            return false;
+        });
+        
+        mocks.mockPaymasterFactory.getPaymaster.mockResolvedValueOnce('0x0000000000000000000000000000000000000000'); // Clean deploy
+        mocks.mockPaymasterFactory.getPaymaster.mockResolvedValueOnce('0x7777777777777777777777777777777777777777'); // After deploy
+
+        const result = await client.deployAndRegisterPaymasterV4();
+
+        expect(mocks.mockPaymasterFactory.deployPaymaster).toHaveBeenCalled();
+        expect(mocks.mockPaymasterFactory.getPaymaster).toHaveBeenCalled();
+        expect(mocks.mockRegistry.registerRoleSelf).toHaveBeenCalledWith(expect.objectContaining({
+            roleId: '0x3333333333333333333333333333333333333333333333333333333333333333'
+        }));
+        expect(result.paymasterAddress).toBe('0x7777777777777777777777777777777777777777');
+      });
+
+      it('deployAndRegisterPaymasterV4 should skip register if already has role', async () => {
+        // Mock getPaymaster to return existing address to exercise idempotency
+        mocks.mockPaymasterFactory.getPaymaster.mockResolvedValue('0x7777777777777777777777777777777777777777');
+        
+        mocks.mockRegistry.hasRole.mockImplementation(async ({ roleId }: any) => {
+            if (roleId === '0x1111111111111111111111111111111111111111111111111111111111111111') return true;
+            if (roleId === '0x3333333333333333333333333333333333333333333333333333333333333333') return true; // Already registered
+            return false;
+        });
+
+        const result = await client.deployAndRegisterPaymasterV4();
+        
+        expect(mocks.mockPaymasterFactory.deployPaymaster).not.toHaveBeenCalled();
+        expect(mocks.mockRegistry.registerRoleSelf).not.toHaveBeenCalled();
+        expect(result.registerHash).toBe('0x0000000000000000000000000000000000000000000000000000000000000000');
+      });
+  });
+
+  describe('Management', () => {
+      it('depositCollateral should approve and deposit', async () => {
+          mocks.mockToken.allowance.mockResolvedValue(0n);
+          await client.depositCollateral(100n);
+          
+          expect(mocks.mockSuperPaymaster.APNTS_TOKEN).toHaveBeenCalled();
+          expect(mocks.mockToken.approve).toHaveBeenCalled();
+          expect(mocks.mockSuperPaymaster.deposit).toHaveBeenCalledWith(expect.objectContaining({
+              amount: 100n
+          }));
+      });
+
+      it('updateExchangeRate should fetch config and call configureOperator', async () => {
+          // Mock operators return [balance, token, treasury, rate]
+          mocks.mockSuperPaymaster.operators.mockResolvedValue({
+              aPNTsBalance: 1000n,
+              xPNTsToken: '0x2222222222222222222222222222222222222222',
+              treasury: '0x3333333333333333333333333333333333333333',
+              exchangeRate: 150n,
+              isConfigured: true,
+              isPaused: false,
+              reputation: 100,
+              minTxInterval: 60,
+              totalSpent: 0n,
+              totalTxSponsored: 0n
+          });
+          mocks.mockSuperPaymaster.configureOperator.mockResolvedValue('0xTxHash');
+
+          await client.updateExchangeRate(200n);
+          
+          expect(mocks.mockSuperPaymaster.operators).toHaveBeenCalledWith(expect.objectContaining({
+              operator: '0x1234567890123456789012345678901234567890' // Default mock address from client.ts
+          }));
+          
+          expect(mocks.mockSuperPaymaster.configureOperator).toHaveBeenCalledWith(expect.objectContaining({
+              xPNTsToken: '0x2222222222222222222222222222222222222222',
+              opTreasury: '0x3333333333333333333333333333333333333333',
+              exchangeRate: 200n
+          }));
+      });
+  });
+
+  describe('Token Config', () => {
+      it('addGasToken should set token price', async () => {
+          await client.addGasToken('0x4444444444444444444444444444444444444444', 100n);
+          expect(mocks.mockPaymasterActions).toHaveBeenCalled(); // Should be called with SP address? No, superPaymasterAddress IS the paymaster for addGasToken (based on code reading)
+          // Wait, addGasToken uses paymasterActions(this.superPaymasterAddress)
+          expect(mocks.mockPaymasterActions).toHaveBeenCalledWith(config.superPaymasterAddress);
+          expect(mocks.mockPaymaster.setTokenPrice).toHaveBeenCalled();
+      });
+
+      it('getTokenPrice should read price', async () => {
+          const price = await client.getTokenPrice('0x4444444444444444444444444444444444444444');
+          expect(price).toBe(100n);
+      });
+  });
+
+  describe('Deposit', () => {
+      it('setupPaymasterDeposit should deposit for user', async () => {
+          await client.setupPaymasterDeposit({
+              paymaster: '0x5555555555555555555555555555555555555555',
+              user: '0x6666666666666666666666666666666666666666',
+              token: '0x4444444444444444444444444444444444444444',
+              amount: 100n
+          });
+          expect(mocks.mockPaymasterActions).toHaveBeenCalledWith('0x5555555555555555555555555555555555555555');
+          expect(mocks.mockPaymaster.depositFor).toHaveBeenCalledWith(expect.objectContaining({
+              user: '0x6666666666666666666666666666666666666666',
+              amount: 100n
+          }));
+      });
+  });
+});

package/__tests__/ProtocolClient.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ProtocolClient } from '../src/ProtocolClient';
+import { createMockPublicClient, createMockWalletClient, resetMocks } from './mocks/client';
+
+// Define mocks using vi.hoisted
+const mocks = vi.hoisted(() => {
+  const mockDVT = { createSlashProposal: vi.fn(), signSlashProposal: vi.fn(), executeSlashWithProof: vi.fn() };
+  const mockAggregator = { registerBLSPublicKey: vi.fn() };
+  const mockSuperPaymaster = { setProtocolFee: vi.fn(), setTreasury: vi.fn() };
+  
+  return {
+    mockDVT,
+    mockAggregator,
+    mockSuperPaymaster,
+    // Factory functions
+    mockDVTActions: vi.fn(() => () => mockDVT),
+    mockAggregatorActions: vi.fn(() => () => mockAggregator),
+    mockSuperPaymasterActions: vi.fn(() => () => mockSuperPaymaster),
+  };
+});
+
+vi.mock('@aastar/core', async () => {
+  const actual = await vi.importActual('@aastar/core');
+  return {
+    ...actual,
+    dvtActions: mocks.mockDVTActions,
+    aggregatorActions: mocks.mockAggregatorActions,
+    superPaymasterActions: mocks.mockSuperPaymasterActions,
+  };
+});
+
+describe('ProtocolClient', () => {
+  let client: ProtocolClient;
+  const mockPublicClient = createMockPublicClient();
+  const mockWalletClient = createMockWalletClient();
+
+  const config = {
+    params: {
+        chainId: 11155111,
+        rpcUrl: 'https://rpc.sepolia.org',
+    },
+    services: {
+        paymasterUrl: 'https://paymaster.example.com',
+    },
+    client: mockWalletClient as any,
+    dvtValidatorAddress: '0x1111111111111111111111111111111111111111' as `0x${string}`,
+    blsAggregatorAddress: '0x2222222222222222222222222222222222222222' as `0x${string}`,
+    superPaymasterAddress: '0x3333333333333333333333333333333333333333' as `0x${string}`
+  };
+
+  beforeEach(() => {
+    resetMocks();
+    vi.clearAllMocks();
+
+    // Default Resolves
+    mocks.mockDVT.createSlashProposal.mockResolvedValue('0xTxHash');
+    mocks.mockDVT.signSlashProposal.mockResolvedValue('0xTxHash');
+    mocks.mockDVT.executeSlashWithProof.mockResolvedValue('0xTxHash');
+    mocks.mockAggregator.registerBLSPublicKey.mockResolvedValue('0xTxHash');
+    mocks.mockSuperPaymaster.setProtocolFee.mockResolvedValue('0xTxHash');
+    mocks.mockSuperPaymaster.setTreasury.mockResolvedValue('0xTxHash');
+
+    client = new ProtocolClient(config);
+    (client as any).client = mockWalletClient;
+    (client as any).publicClient = mockPublicClient;
+  });
+
+  describe('DVT Proposals', () => {
+    it('createProposal should call createSlashProposal', async () => {
+      const result = await client.createProposal('0x4444444444444444444444444444444444444444', '0x1234', 'Description');
+      
+      expect(mocks.mockDVTActions).toHaveBeenCalledWith(config.dvtValidatorAddress);
+      expect(mocks.mockDVT.createSlashProposal).toHaveBeenCalledWith(expect.objectContaining({
+          operator: '0x4444444444444444444444444444444444444444',
+          level: 1,
+          reason: 'Description'
+      }));
+      expect(result).toBe('0xTxHash');
+    });
+
+    it('signProposal should call signSlashProposal', async () => {
+        await client.signProposal(1n, '0x5555');
+        expect(mocks.mockDVT.signSlashProposal).toHaveBeenCalledWith(expect.objectContaining({
+            proposalId: 1n,
+            signature: '0x5555'
+        }));
+    });
+
+    it('executeWithProof should call executeSlashWithProof', async () => {
+        await client.executeWithProof(1n, ['0x5555']);
+        expect(mocks.mockDVT.executeSlashWithProof).toHaveBeenCalledWith(expect.objectContaining({
+            proposalId: 1n,
+            // proof is mocked inside implementation
+        }));
+    });
+  });
+
+  describe('BLS Management', () => {
+      it('registerBLSKey should call registerBLSPublicKey', async () => {
+          await client.registerBLSKey('0x123456');
+          expect(mocks.mockAggregatorActions).toHaveBeenCalledWith(config.blsAggregatorAddress);
+          expect(mocks.mockAggregator.registerBLSPublicKey).toHaveBeenCalledWith(expect.objectContaining({
+              publicKey: '0x123456'
+          }));
+      });
+
+      it('should throw if blsAggregatorAddress missing', async () => {
+          client.blsAggregatorAddress = undefined;
+          await expect(client.registerBLSKey('0x12')).rejects.toThrow('BLS Aggregator address required');
+      });
+  });
+
+  describe('Global Params', () => {
+      it('setProtocolFee should call superPaymaster', async () => {
+          await client.setProtocolFee(100n);
+          expect(mocks.mockSuperPaymasterActions).toHaveBeenCalledWith(config.superPaymasterAddress);
+          expect(mocks.mockSuperPaymaster.setProtocolFee).toHaveBeenCalledWith(expect.objectContaining({
+              newFeeBPS: 100n
+          }));
+      });
+
+      it('setTreasury should call superPaymaster', async () => {
+          await client.setTreasury('0x7777777777777777777777777777777777777777');
+          expect(mocks.mockSuperPaymaster.setTreasury).toHaveBeenCalledWith(expect.objectContaining({
+              treasury: '0x7777777777777777777777777777777777777777'
+          }));
+      });
+
+      it('should throw if superPaymasterAddress missing', async () => {
+          client.superPaymasterAddress = undefined;
+          await expect(client.setTreasury('0x1111111111111111111111111111111111111111')).rejects.toThrow('SuperPaymaster address required');
+      });
+  });
+
+});

package/__tests__/index.test.ts

@@ -0,0 +1,16 @@
+
+import { PaymasterOperatorClient } from '../src/PaymasterOperatorClient';
+import { ProtocolClient } from '../src/ProtocolClient';
+import * as Exports from '../src/index';
+
+describe('Operator Package Exports', () => {
+    it('should export PaymasterOperatorClient', () => {
+        expect(Exports.PaymasterOperatorClient).toBeDefined();
+        expect(Exports.PaymasterOperatorClient).toBe(PaymasterOperatorClient);
+    });
+
+    it('should export ProtocolClient', () => {
+        expect(Exports.ProtocolClient).toBeDefined();
+        expect(Exports.ProtocolClient).toBe(ProtocolClient);
+    });
+});

package/__tests__/mocks/client.ts

@@ -0,0 +1,22 @@
+import { vi } from 'vitest';
+import type { PublicClient, WalletClient } from 'viem';
+
+export const createMockPublicClient = (): PublicClient => {
+  return {
+    readContract: vi.fn(),
+    chain: { id: 11155111 },
+    waitForTransactionReceipt: vi.fn().mockResolvedValue({ status: 'success' }),
+  } as any;
+};
+
+export const createMockWalletClient = (): WalletClient => {
+  return {
+    writeContract: vi.fn(),
+    account: { address: '0x1234567890123456789012345678901234567890' },
+    chain: { id: 11155111 },
+  } as any;
+};
+
+export const resetMocks = () => {
+  vi.clearAllMocks();
+};

package/dist/PaymasterOperatorClient.d.ts

@@ -0,0 +1,82 @@
+import { type Address, type Hash } from 'viem';
+import { BaseClient, type ClientConfig, type TransactionOptions } from '@aastar/core';
+export interface OperatorClientConfig extends ClientConfig {
+    superPaymasterAddress: Address;
+    tokenAddress?: Address;
+}
+export interface SponsorshipPolicy {
+    globalLimit: bigint;
+    userLimit: bigint;
+    itemPrice: bigint;
+}
+/**
+ * Client for Paymaster Operators (ROLE_PAYMASTER_SUPER)
+ */
+export declare class PaymasterOperatorClient extends BaseClient {
+    superPaymasterAddress: Address;
+    tokenAddress?: Address;
+    ethUsdPriceFeed: Address;
+    xpntsFactory: Address;
+    constructor(config: OperatorClientConfig);
+    /**
+     * Register as SuperPaymaster Operator (one-stop API).
+     * This method handles all necessary steps:
+     * 1. Checks prerequisites (must have ROLE_COMMUNITY)
+     * 2. Checks and approves GToken to GTokenStaking
+     * 3. Registers ROLE_PAYMASTER_SUPER
+     * 4. Optionally deposits collateral to SuperPaymaster
+     *
+     * @param params Registration parameters
+     * @param options Transaction options
+     * @returns Transaction hash of role registration
+     */
+    registerAsSuperPaymasterOperator(params?: {
+        stakeAmount?: bigint;
+        depositAmount?: bigint;
+    }, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Deploy a new Paymaster V4 and Register as AOA Operator (one-stop API).
+     * This method handles:
+     * 1. Checks prerequisites (ROLE_COMMUNITY)
+     * 2. Predicts new Paymaster address
+     * 3. Deploys Paymaster V4 via Factory
+     * 4. Registers ROLE_PAYMASTER_AOA with staking
+     *
+     * @param params Deployment parameters
+     * @param options Transaction options
+     * @returns Object containing new paymaster address and transaction hashes
+     */
+    deployAndRegisterPaymasterV4(params?: {
+        stakeAmount?: bigint;
+        version?: string;
+        salt?: bigint;
+    }, options?: TransactionOptions): Promise<{
+        paymasterAddress: Address;
+        deployHash: Hash;
+        registerHash: Hash;
+    }>;
+    /**
+     * Deposit collateral (aPNTs/GToken) to SuperPaymaster.
+     * This is a helper method used by registerAsSuperPaymasterOperator.
+     */
+    depositCollateral(amount: bigint, options?: TransactionOptions): Promise<Hash>;
+    updateExchangeRate(exchangeRate: bigint, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Configure operator parameters (Token, Treasury, Exchange Rate).
+     * If parameters are undefined, existing values are preserved.
+     */
+    configureOperator(xPNTsToken?: Address, treasury?: Address, exchangeRate?: bigint, options?: TransactionOptions): Promise<Hash>;
+    withdrawCollateral(to: Address, amount: bigint, options?: TransactionOptions): Promise<Hash>;
+    isOperator(operator: Address): Promise<boolean>;
+    getOperatorDetails(operator?: Address): Promise<any>;
+    initiateExit(options?: TransactionOptions): Promise<Hash>;
+    withdrawStake(to: Address, options?: TransactionOptions): Promise<Hash>;
+    addGasToken(token: Address, price: bigint, options?: TransactionOptions): Promise<Hash>;
+    getTokenPrice(token: Address): Promise<bigint>;
+    setupPaymasterDeposit(params: {
+        paymaster: Address;
+        user: Address;
+        token: Address;
+        amount: bigint;
+    }, options?: TransactionOptions): Promise<Hash>;
+}