@aastar/sdk 0.16.11 → 0.16.12

package/dist/clients/operator.d.ts

@@ -0,0 +1,66 @@
+import { type Client, type Transport, type Chain, type Account, type Hash, type Hex, type PublicActions, type WalletActions, type Address } from 'viem';
+import { type StakingActions, type RegistryActions, type SuperPaymasterActions, type PaymasterActions } from '@aastar/core';
+export type OperatorClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SuperPaymasterActions & PaymasterActions & StakingActions & {
+    /**
+     * High-level API: Setup operator with automatic funding and onboarding
+     */
+    setup: (args: {
+        stakeAmount: bigint;
+        depositAmount: bigint;
+        roleId: Hex;
+        roleData?: Hex;
+    }) => Promise<{
+        txs: Hash[];
+    }>;
+    deployPaymasterV4: (args?: {
+        version?: string;
+        initData?: Hex;
+    }) => Promise<Hash>;
+    /**
+     * Orchestrates the full onboarding flow:
+     * 1. Approve GToken (Stake)
+     * 2. Register Role (Stake Lock)
+     * 3. Approve aPNTs (Deposit)
+     * 4. Deposit aPNTs (SuperPaymaster)
+     */
+    onboardOperator: (args: {
+        stakeAmount: bigint;
+        depositAmount: bigint;
+        roleId: Hex;
+        roleData?: Hex;
+    }) => Promise<Hash[]>;
+    /** @deprecated Use onboardOperator */
+    onboardToSuperPaymaster: (args: {
+        stakeAmount: bigint;
+        depositAmount: bigint;
+        roleId: Hex;
+    }) => Promise<Hash[]>;
+    configureOperator: (args: {
+        xPNTsToken: Address;
+        treasury: Address;
+        exchangeRate: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getOperatorStatus: (accountAddress: Address) => Promise<{
+        type: 'super' | 'v4' | null;
+        superPaymaster: {
+            hasRole: boolean;
+            isConfigured: boolean;
+            balance: bigint;
+            exchangeRate: bigint;
+            treasury: Address;
+        } | null;
+        paymasterV4: {
+            address: Address;
+            balance: bigint;
+        } | null;
+    }>;
+};
+export declare function createOperatorClient({ chain, transport, account, addresses }: {
+    chain: Chain;
+    transport: Transport;
+    account?: Account;
+    addresses?: {
+        [key: string]: Address;
+    };
+}): OperatorClient;

package/{packages/sdk/src/clients/operator.ts → dist/clients/operator.js}

@@ -1,105 +1,40 @@
-import { createClient, type Client, type Transport, type Chain, type Account, type Hash, type Hex, erc20Abi, parseAbi, publicActions, walletActions, type PublicActions, type WalletActions, type Address, keccak256, stringToBytes } from 'viem';
-
-import { 
-    stakingActions, 
-    registryActions,
-    RegistryABI,
-    superPaymasterActions,
-
-    paymasterActions,
-    PaymasterFactoryABI,
-    type StakingActions, 
-    type RegistryActions,
-    type SuperPaymasterActions,
-    type PaymasterActions,
-    CORE_ADDRESSES,
-    TEST_TOKEN_ADDRESSES,
-    TEST_ACCOUNT_ADDRESSES
-} from '@aastar/core';
+import { createClient, erc20Abi, parseAbi, publicActions, walletActions, keccak256, stringToBytes } from 'viem';
+import { stakingActions, registryActions, RegistryABI, superPaymasterActions, paymasterActions, PaymasterFactoryABI, CORE_ADDRESSES, TEST_TOKEN_ADDRESSES, TEST_ACCOUNT_ADDRESSES } from '@aastar/core';
 import { RoleDataFactory } from '../utils/roleData.js';
 import { decodeContractError } from '../errors/decoder.js';
-
-export type OperatorClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SuperPaymasterActions & PaymasterActions & StakingActions & {
-    /**
-     * High-level API: Setup operator with automatic funding and onboarding
-     */
-    setup: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) => Promise<{ txs: Hash[] }>;
-    deployPaymasterV4: (args?: { version?: string, initData?: Hex }) => Promise<Hash>;
-    /**
-     * Orchestrates the full onboarding flow:
-     * 1. Approve GToken (Stake)
-     * 2. Register Role (Stake Lock)
-     * 3. Approve aPNTs (Deposit)
-     * 4. Deposit aPNTs (SuperPaymaster)
-     */
-    onboardOperator: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) => Promise<Hash[]>;
-    /** @deprecated Use onboardOperator */
-    onboardToSuperPaymaster: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex }) => Promise<Hash[]>
-    configureOperator: (args: { xPNTsToken: Address, treasury: Address, exchangeRate: bigint, account?: Account | Address }) => Promise<Hash>
-    getOperatorStatus: (accountAddress: Address) => Promise<{
-        type: 'super' | 'v4' | null;
-        superPaymaster: {
-            hasRole: boolean;
-            isConfigured: boolean;
-            balance: bigint;
-            exchangeRate: bigint;
-            treasury: Address;
-        } | null;
-        paymasterV4: {
-            address: Address;
-            balance: bigint;
-        } | null;
-    }>
-};
-
-
-export function createOperatorClient({ 
-    chain, 
-    transport, 
-    account,
-    addresses
-}: { 
-    chain: Chain, 
-    transport: Transport,
-    account?: Account,
-    addresses?: { [key: string]: Address }
-}): OperatorClient {
-    const client = createClient({ 
-        chain, 
+export function createOperatorClient({ chain, transport, account, addresses }) {
+    const client = createClient({
+        chain,
         transport,
         account
     })
-    .extend(publicActions)
-    .extend(walletActions);
-
+        .extend(publicActions)
+        .extend(walletActions);
     const usedAddresses = { ...CORE_ADDRESSES, ...TEST_TOKEN_ADDRESSES, ...TEST_ACCOUNT_ADDRESSES, ...addresses };
-
-    const spActions = superPaymasterActions(usedAddresses.superPaymaster)(client as any);
-    const regActions = registryActions(usedAddresses.registry)(client as any);
-    const stkActions = stakingActions(usedAddresses.gTokenStaking)(client as any);
-    const pmV4Actions = paymasterActions(usedAddresses.paymasterV4)(client as any);
-
+    const spActions = superPaymasterActions(usedAddresses.superPaymaster)(client);
+    const regActions = registryActions(usedAddresses.registry)(client);
+    const stkActions = stakingActions(usedAddresses.gTokenStaking)(client);
+    const pmV4Actions = paymasterActions(usedAddresses.paymasterV4)(client);
     const actions = {
         ...stkActions,
         ...spActions,
         ...pmV4Actions,
         ...regActions,
-
-        async setup(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) {
+        async setup(args) {
             console.log('⚙️ Setting up operator...');
-            const txs = await (this as any)._onboardOperator(args);
+            const txs = await this._onboardOperator(args);
             console.log(`✅ Operator setup complete! Transactions: ${txs.length}`);
             return { txs };
         },
-        async onboardOperator(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) {
+        async onboardOperator(args) {
             return this.onboardFully(args);
         },
-        async onboardFully(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) {
-            return (this as any)._onboardOperator(args);
+        async onboardFully(args) {
+            return this._onboardOperator(args);
         },
-        async deployPaymasterV4({ version = 'v4.1', initData = '0x' }: { version?: string, initData?: Hex } = {}) {
+        async deployPaymasterV4({ version = 'v4.1', initData = '0x' } = {}) {
             console.log(`   SDK: Deploying Paymaster V4 (${version})...`);
-            const tx = await (client as any).writeContract({
+            const tx = await client.writeContract({
                 address: usedAddresses.paymasterFactory,
                 abi: PaymasterFactoryABI,
                 functionName: 'deployPaymaster',
@@ -107,29 +42,27 @@ export function createOperatorClient({
                 account,
                 chain
             });
-            await (client as any).waitForTransactionReceipt({ hash: tx });
+            await client.waitForTransactionReceipt({ hash: tx });
             return tx;
         },
-        async _onboardOperator({ stakeAmount, depositAmount, roleId, roleData }: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) {
-            const txs: Hash[] = [];
-            const accountToUse = account; 
-            if (!accountToUse) throw new Error("Account required for onboarding");
-
+        async _onboardOperator({ stakeAmount, depositAmount, roleId, roleData }) {
+            const txs = [];
+            const accountToUse = account;
+            if (!accountToUse)
+                throw new Error("Account required for onboarding");
             try {
                 // 1. Fetch Entry Burn & Approve GToken
                 console.log('   SDK: Fetching role config for entry burn...');
-                const roleConfig = await (client as any).readContract({
+                const roleConfig = await client.readContract({
                     address: usedAddresses.registry,
                     abi: RegistryABI,
                     functionName: 'roleConfigs',
                     args: [roleId]
-                }) as any; 
-
-                const entryBurn = roleConfig[1]; 
+                });
+                const entryBurn = roleConfig[1];
                 const totalStakeNeeded = stakeAmount + entryBurn;
-
                 console.log(`   SDK: Approving GToken (Stake: ${stakeAmount}, Burn: ${entryBurn})...`);
-                const approveGToken = await (client as any).writeContract({
+                const approveGToken = await client.writeContract({
                     address: usedAddresses.gToken,
                     abi: erc20Abi,
                     functionName: 'approve',
@@ -137,50 +70,51 @@ export function createOperatorClient({
                     account: accountToUse,
                     chain
                 });
-                await (client as any).waitForTransactionReceipt({ hash: approveGToken });
+                await client.waitForTransactionReceipt({ hash: approveGToken });
                 txs.push(approveGToken);
-
                 // 2. Register Role
-                let data: Hex;
+                let data;
                 if (roleData && roleData !== '0x') {
                     data = roleData;
-                } else {
+                }
+                else {
                     console.log(`   SDK: Auto-generating roleData for roleId ${roleId}...`);
                     if (roleId === keccak256(stringToBytes('COMMUNITY'))) {
                         data = RoleDataFactory.community();
-                    } else if (roleId === keccak256(stringToBytes('ENDUSER'))) {
+                    }
+                    else if (roleId === keccak256(stringToBytes('ENDUSER'))) {
                         data = RoleDataFactory.endUser();
-                    } else if (roleId === keccak256(stringToBytes('PAYMASTER_SUPER'))) {
+                    }
+                    else if (roleId === keccak256(stringToBytes('PAYMASTER_SUPER'))) {
                         data = RoleDataFactory.paymasterSuper();
-                    } else {
+                    }
+                    else {
                         data = RoleDataFactory.paymasterSuper();
                     }
                 }
-                
                 console.log(`   SDK: Checking if role already granted...`);
-                const hasRoleResult = await (client as any).readContract({
+                const hasRoleResult = await client.readContract({
                     address: usedAddresses.registry,
                     abi: RegistryABI,
                     functionName: 'hasRole',
-                    args: [roleId, accountToUse!.address]
-                }) as boolean;
-
+                    args: [roleId, accountToUse.address]
+                });
                 if (hasRoleResult) {
                     console.log(`   ℹ️  Role already granted, skipping registration`);
-                } else {
+                }
+                else {
                     console.log(`   SDK: Registering role ${roleId}...`);
                     const registerTx = await actions.registerRoleSelf({
                         roleId,
-                        data, 
+                        data,
                         account: accountToUse
                     });
-                    await (client as any).waitForTransactionReceipt({ hash: registerTx });
+                    await client.waitForTransactionReceipt({ hash: registerTx });
                     txs.push(registerTx);
                 }
-
                 if (depositAmount > 0n) {
                     console.log('   SDK: Depositing aPNTs via depositFor...');
-                    const depositTx = await (client as any).writeContract({
+                    const depositTx = await client.writeContract({
                         address: usedAddresses.superPaymaster,
                         abi: parseAbi(['function depositFor(address targetOperator, uint256 amount) external']),
                         functionName: 'depositFor',
@@ -188,51 +122,48 @@ export function createOperatorClient({
                         account: accountToUse,
                         chain
                     });
-                    await (client as any).waitForTransactionReceipt({ hash: depositTx });
+                    await client.waitForTransactionReceipt({ hash: depositTx });
                     txs.push(depositTx);
                 }
-
                 return txs;
-            } catch (error) {
+            }
+            catch (error) {
                 const decodedMsg = decodeContractError(error);
                 throw decodedMsg ? new Error(`Onboarding Failed: ${decodedMsg}`) : error;
             }
         },
-        async onboardToSuperPaymaster(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex }) {
+        async onboardToSuperPaymaster(args) {
             return this.onboardOperator(args);
         },
-        async configureOperator({ xPNTsToken, treasury, exchangeRate, account: accountOverride }: { xPNTsToken: Address, treasury: Address, exchangeRate: bigint, account?: Account | Address }) {
-            const tx = await spActions.configureOperator({ 
-                xPNTsToken, 
-                opTreasury: treasury, 
+        async configureOperator({ xPNTsToken, treasury, exchangeRate, account: accountOverride }) {
+            const tx = await spActions.configureOperator({
+                xPNTsToken,
+                opTreasury: treasury,
                 exchangeRate,
                 account: accountOverride || account
             });
-            await (client as any).waitForTransactionReceipt({ hash: tx });
+            await client.waitForTransactionReceipt({ hash: tx });
             return tx;
         },
-        async getOperatorStatus(accountAddress: Address) {
+        async getOperatorStatus(accountAddress) {
             try {
                 const hasRole = await client.readContract({
                     address: usedAddresses.registry,
                     abi: RegistryABI,
                     functionName: 'hasRole',
                     args: [keccak256(stringToBytes('PAYMASTER_SUPER')), accountAddress]
-                }) as boolean;
-
-                let operatorType: 'super' | 'v4' | null = null;
+                });
+                let operatorType = null;
                 let superPaymasterInfo = null;
                 let paymasterV4Info = null;
-
                 if (hasRole && usedAddresses.superPaymaster) {
                     const pmAbi = parseAbi(['function operators(address) view returns (uint128 balance, uint96 exchangeRate, bool isConfigured, bool isPaused, address token, uint32 reputation, address treasury, uint256 spent, uint256 txSponsored)']);
                     const operatorData = await client.readContract({
-                        address: usedAddresses.superPaymaster!,
+                        address: usedAddresses.superPaymaster,
                         abi: pmAbi,
                         functionName: 'operators',
                         args: [accountAddress]
-                    }) as any;
-
+                    });
                     if (operatorData && operatorData[2]) { // isConfigured
                         operatorType = 'super';
                         superPaymasterInfo = {
@@ -244,7 +175,6 @@ export function createOperatorClient({
                         };
                     }
                 }
-                
                 // 检查 Paymaster V4 (Direct)
                 if (usedAddresses.paymasterFactory && usedAddresses.paymasterFactory !== '0x0000000000000000000000000000000000000000') {
                     try {
@@ -254,8 +184,7 @@ export function createOperatorClient({
                             abi: factoryAbi,
                             functionName: 'getPaymasterByOperator',
                             args: [accountAddress]
-                        }) as Address;
-            
+                        });
                         if (pmAddr !== '0x0000000000000000000000000000000000000000') {
                             operatorType = operatorType || 'v4';
                             paymasterV4Info = {
@@ -263,18 +192,18 @@ export function createOperatorClient({
                                 balance: await client.getBalance({ address: pmAddr })
                             };
                         }
-                    } catch (e) {
+                    }
+                    catch (e) {
                         console.warn(`   ⚠️ Failed to fetch V4 info from factory ${usedAddresses.paymasterFactory}:`, e);
                     }
                 }
-
                 return { type: operatorType, superPaymaster: superPaymasterInfo, paymasterV4: paymasterV4Info };
-            } catch (error) {
+            }
+            catch (error) {
                 console.error('Error in getOperatorStatus:', error);
                 return { type: null, superPaymaster: null, paymasterV4: null };
             }
         }
     };
-
-    return Object.assign(client, actions) as unknown as OperatorClient;
+    return Object.assign(client, actions);
 }

package/dist/clients/operator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/operator.test.js

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createOperatorClient } from './operator.js';
+import { mainnet } from 'viem/chains';
+import { http, keccak256, stringToBytes } from 'viem';
+vi.mock('@aastar/core', async () => {
+    const actual = await vi.importActual('@aastar/core');
+    return {
+        ...actual,
+        registryActions: vi.fn(() => vi.fn(() => ({
+            registryHasRole: vi.fn().mockResolvedValue(false),
+            registryRegisterRoleSelf: vi.fn().mockResolvedValue('0xhash')
+        }))),
+        stakingActions: vi.fn(() => vi.fn(() => ({
+        // any staking methods if needed
+        }))),
+        superPaymasterActions: vi.fn(() => vi.fn(() => ({
+            superPaymasterDepositFor: vi.fn().mockResolvedValue('0xhash'),
+            superPaymasterOperators: vi.fn().mockResolvedValue([1000n, 1000n, true, false]),
+            superPaymasterGetDeposit: vi.fn().mockResolvedValue(555n)
+        }))),
+        paymasterV4Actions: vi.fn(() => vi.fn(() => ({
+        // pmv4 methods
+        }))),
+        tokenActions: vi.fn(() => vi.fn(() => ({
+            tokenApprove: vi.fn().mockResolvedValue('0xhash')
+        }))),
+    };
+});
+describe('OperatorClient', () => {
+    const MOCK_ADDR = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
+    it('should create operator client', () => {
+        const client = createOperatorClient({ chain: mainnet, transport: http() });
+        expect(client.setup).toBeDefined();
+    });
+    describe('onboardFully', () => {
+        it('should complete onboarding flow', async () => {
+            const client = createOperatorClient({
+                chain: mainnet,
+                transport: http(),
+                account: { address: MOCK_ADDR }
+            });
+            // Mock base client methods
+            client.readContract = vi.fn().mockResolvedValue([0n, 0n, 0n]);
+            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
+            const results = await client.onboardFully({
+                stakeAmount: 100n,
+                depositAmount: 200n,
+                roleId: keccak256(stringToBytes('PAYMASTER_SUPER'))
+            });
+            expect(results).toHaveLength(3);
+            expect(client.tokenApprove).toHaveBeenCalled();
+            expect(client.registryRegisterRoleSelf).toHaveBeenCalled();
+            expect(client.superPaymasterDepositFor).toHaveBeenCalled();
+        });
+    });
+    describe('Advanced Setup', () => {
+        it('should call configureOperator', async () => {
+            const client = createOperatorClient({ chain: mainnet, transport: http() });
+            client.configureOperator = vi.fn().mockResolvedValue('0xhash');
+            const hash = await client.configureOperator({
+                xPNTsToken: MOCK_ADDR,
+                treasury: MOCK_ADDR,
+                exchangeRate: 100n
+            });
+            expect(hash).toBe('0xhash');
+        });
+        it('should onboard to Super Paymaster', async () => {
+            const client = createOperatorClient({
+                chain: mainnet,
+                transport: http(),
+                account: { address: MOCK_ADDR }
+            });
+            client.onboardFully = vi.fn().mockResolvedValue([]);
+            // onboardToSuperPaymaster is an internal action alias in OperatorClient
+            await client.onboardToSuperPaymaster({ stakeAmount: 100n, depositAmount: 200n, roleId: '0x1' });
+            expect(client.onboardFully).toHaveBeenCalled();
+        });
+        it('should deploy PaymasterV4', async () => {
+            const client = createOperatorClient({ chain: mainnet, transport: http(), account: { address: MOCK_ADDR } });
+            client.writeContract = vi.fn().mockResolvedValue('0xdeployhash');
+            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({});
+            const hash = await client.deployPaymasterV4({ version: 'v4.2' });
+            expect(hash).toBe('0xdeployhash');
+        });
+        it('should validate inputs in configureOperator', async () => {
+            const opClient = createOperatorClient({
+                account: { address: MOCK_ADDR },
+                chain: mainnet,
+                transport: http()
+            });
+            // No need to mock internal configureOperator for validation testing 
+            // as validation happens before internal call.
+            await expect(opClient.configureOperator({
+                xPNTsToken: '0xInvalid',
+                treasury: '0x123',
+                exchangeRate: 100n
+            })).rejects.toThrow('xPNTs Token must be a valid Ethereum address');
+            await expect(opClient.configureOperator({
+                xPNTsToken: MOCK_ADDR,
+                treasury: '0xInvalid',
+                exchangeRate: 100n
+            })).rejects.toThrow('Treasury must be a valid Ethereum address');
+        });
+        it('should check readiness', async () => {
+            const opClient = createOperatorClient({
+                account: { address: MOCK_ADDR },
+                chain: mainnet,
+                transport: http()
+            });
+            // Global mock for registryActions.hasRole returns false
+            // Global mock for superPaymasterActions.operators returns [1000n, 1000n, true, false]
+            const status = await opClient.checkReadiness();
+            expect(status.isRegistered).toBe(false); // mocked val
+            expect(status.isConfigured).toBe(true); // mocked val (index 2)
+            expect(status.collateralBalance).toBe(1000n); // mocked val (index 0)
+        });
+    });
+    describe('Operator Status and Queries', () => {
+        it('should get operator status', async () => {
+            const client = createOperatorClient({ chain: mainnet, transport: http() });
+            client.readContract = vi.fn()
+                .mockResolvedValueOnce(true) // hasRole
+                .mockResolvedValueOnce([1000n, 100n, true, false, 0n, 0n, MOCK_ADDR]); // operator data
+            const status = await client.getOperatorStatus(MOCK_ADDR);
+            expect(status.type).toBe('super');
+            expect(status.superPaymaster?.isConfigured).toBe(true);
+        });
+        it('should check if address is operator', async () => {
+            const client = createOperatorClient({ chain: mainnet, transport: http() });
+            const result = await client.isOperator(MOCK_ADDR);
+            expect(result).toBe(true); // from mocked operators
+        });
+        it('should get deposit details', async () => {
+            const client = createOperatorClient({ chain: mainnet, transport: http() });
+            const details = await client.getDepositDetails();
+            expect(details.deposit).toBe(555n); // from mocked getDeposit
+        });
+    });
+});