@aastar/sdk 0.16.11 → 0.16.14

package/dist/clients/clients.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createEndUserClient } from './endUser.js';
+import { createCommunityClient } from './community.js';
+import { createOperatorClient } from './operator.js';
+import { createAdminClient } from './admin.js';
+import { http } from 'viem';
+import { mainnet } from 'viem/chains';
+describe('SDK L2 Clients', () => {
+    let mockTransport;
+    let mockChain;
+    let mockAccount;
+    const MOCK_ADDR = '0x1111111111111111111111111111111111111111';
+    beforeEach(() => {
+        mockTransport = http('http://localhost:8545');
+        mockChain = mainnet;
+        mockAccount = {
+            address: MOCK_ADDR,
+            type: 'json-rpc',
+            signMessage: vi.fn().mockResolvedValue('0xsignature')
+        };
+    });
+    describe('EndUserClient', () => {
+        let client;
+        beforeEach(() => {
+            client = createEndUserClient({ chain: mockChain, transport: mockTransport, account: mockAccount });
+            client.readContract = vi.fn();
+            client.writeContract = vi.fn().mockResolvedValue('0xhash');
+            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
+            client.getBytecode = vi.fn().mockResolvedValue('0x123');
+        });
+        it('should create EndUserClient', () => {
+            expect(client.onboard).toBeDefined();
+        });
+        it('should create smart account', async () => {
+            client.readContract.mockResolvedValue(MOCK_ADDR);
+            const result = await client.createSmartAccount({ owner: MOCK_ADDR });
+            expect(result.accountAddress).toBe(MOCK_ADDR);
+            expect(result.initCode).toBeDefined();
+        });
+        it('should execute gasless transaction', async () => {
+            client.readContract.mockResolvedValue(0n); // nonce
+            client.readContract.mockResolvedValueOnce(0n).mockResolvedValueOnce('0xhash'); // nonce, userOpHash
+            client.createSmartAccount = vi.fn().mockResolvedValue({ accountAddress: MOCK_ADDR, initCode: '0x' });
+            const result = await client.executeGasless({
+                target: MOCK_ADDR,
+                data: '0x',
+                operator: MOCK_ADDR
+            });
+            expect(result.hash).toBe('0xhash');
+        });
+    });
+    describe('CommunityClient', () => {
+        it('should launch community', async () => {
+            const client = createCommunityClient({ chain: mockChain, transport: mockTransport, account: mockAccount });
+            client.writeContract = vi.fn().mockResolvedValue('0xhash');
+            client.simulateContract = vi.fn().mockResolvedValue({ request: {} });
+            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
+            client.readContract = vi.fn().mockResolvedValue(MOCK_ADDR);
+            const result = await client.launch({
+                name: 'Test',
+                tokenName: 'TT',
+                tokenSymbol: 'TT'
+            });
+            expect(result.tokenAddress).toBe(MOCK_ADDR);
+            expect(result.results.length).toBeGreaterThan(0);
+        });
+    });
+    describe('OperatorClient', () => {
+        it('should setup operator', async () => {
+            const client = createOperatorClient({ chain: mockChain, transport: mockTransport, account: mockAccount });
+            client.readContract = vi.fn().mockResolvedValue(['', 0n]); // roleConfig
+            client.writeContract = vi.fn().mockResolvedValue('0xhash');
+            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
+            client.registryHasRole = vi.fn().mockResolvedValue(false);
+            const result = await client.setup({
+                stakeAmount: 100n,
+                depositAmount: 100n,
+                roleId: '0x1'
+            });
+            expect(result.txs.length).toBeGreaterThan(0);
+        });
+    });
+    describe('AdminClient', () => {
+        it('should have namespaces', () => {
+            const client = createAdminClient({ chain: mockChain, transport: mockTransport, account: mockAccount });
+            expect(client.system).toBeDefined();
+            expect(client.finance).toBeDefined();
+            expect(client.operators).toBeDefined();
+        });
+    });
+});

package/dist/clients/community.d.ts

@@ -0,0 +1,40 @@
+import { type Client, type Transport, type Chain, type Account, type Hex, type PublicActions, type WalletActions, type Address } from 'viem';
+import { type RegistryActions, type SBTActions } from '@aastar/core';
+export type CommunityClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SBTActions & {
+    /**
+     * Query community registration status and token information
+     * Returns null if not registered, otherwise returns community details
+     */
+    getCommunityInfo: (accountAddress: Address) => Promise<{
+        hasRole: boolean;
+        tokenAddress: Address | null;
+        communityData: {
+            name: string;
+            ensName: string;
+            website: string;
+            description: string;
+        } | null;
+    }>;
+    /**
+     * High-level API to launch a community with automatic roleData generation
+     */
+    launch: (args: {
+        name: string;
+        tokenName: string;
+        tokenSymbol: string;
+        description?: string;
+        logoURI?: string;
+        website?: string;
+    }) => Promise<{
+        tokenAddress: Address;
+        txs: Hex[];
+    }>;
+};
+export declare function createCommunityClient({ chain, transport, account, addresses }: {
+    chain: Chain;
+    transport: Transport;
+    account?: Account;
+    addresses?: {
+        [key: string]: Address;
+    };
+}): CommunityClient;

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

@@ -1,103 +1,26 @@
-import { 
-    createClient, 
-    type Client, 
-    type Transport, 
-    type Chain, 
-    type Account, 
-    type Hash, 
-    type Hex,
-    publicActions,
-    walletActions,
-    type PublicActions,
-    type WalletActions,
-    type Address,
-    keccak256,
-    stringToBytes,
-    erc20Abi
-} from 'viem';
-
-import { 
-    registryActions, 
-    RegistryABI, 
-    sbtActions,
-    type RegistryActions,
-    type SBTActions,
-    CORE_ADDRESSES,
-    TEST_TOKEN_ADDRESSES
-} from '@aastar/core';
+import { createClient, publicActions, walletActions, erc20Abi } from 'viem';
+import { registryActions, RegistryABI, sbtActions, CORE_ADDRESSES, TEST_TOKEN_ADDRESSES } from '@aastar/core';
 import { RoleDataFactory, RoleIds } from '../utils/roleData.js';
-
-export type CommunityClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SBTActions & {
-    /**
-     * Query community registration status and token information
-     * Returns null if not registered, otherwise returns community details
-     */
-    getCommunityInfo: (accountAddress: Address) => Promise<{
-        hasRole: boolean;
-        tokenAddress: Address | null;
-        communityData: {
-            name: string;
-            ensName: string;
-            website: string;
-            description: string;
-        } | null;
-    }>;
-    /**
-     * High-level API to launch a community with automatic roleData generation
-     */
-    launch: (args: {
-        name: string;
-        tokenName: string;
-        tokenSymbol: string;
-        description?: string;
-        logoURI?: string;
-        website?: string;
-    }) => Promise<{ tokenAddress: Address; txs: Hex[] }>;
-};
-
-export function createCommunityClient({ 
-    chain, 
-    transport, 
-    account,
-    addresses
-}: { 
-    chain: Chain, 
-    transport: Transport,
-    account?: Account,
-    addresses?: { [key: string]: Address }
-}): CommunityClient {
-    const client = createClient({ 
-        chain, 
+export function createCommunityClient({ 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, ...addresses };
-
-    const registryActionsObj = registryActions(usedAddresses.registry)(client as any);
-    const sbtActionsObj = sbtActions(usedAddresses.mySBT)(client as any);
-
-    const launch = async (args: {
-        name: string;
-        tokenName: string;
-        tokenSymbol: string;
-        description?: string;
-        logoURI?: string;
-        website?: string;
-    }): Promise<{ tokenAddress: Address; txs: Hex[] }> => {
+    const registryActionsObj = registryActions(usedAddresses.registry)(client);
+    const sbtActionsObj = sbtActions(usedAddresses.mySBT)(client);
+    const launch = async (args) => {
         try {
             console.log(`🚀 Launching community: ${args.name}`);
-            
             if (!account) {
                 throw new Error('Account is required for launch()');
             }
-
             // Generate unique community name with timestamp
             const uniqueName = `${args.name}_${Date.now()}`;
             console.log(`   📝 Unique name: ${uniqueName}`);
-
             // Generate roleData using RoleDataFactory
             const roleData = RoleDataFactory.community({
                 name: uniqueName,
@@ -110,20 +33,18 @@ export function createCommunityClient({
             console.log(`   ✅ RoleData generated:`, roleData);
             console.log(`   📊 RoleData type:`, typeof roleData);
             console.log(`   📏 RoleData length:`, roleData?.length);
-
             // 1. Check if already has role
             const hasRole = await client.readContract({
                 address: usedAddresses.registry,
                 abi: RegistryABI,
                 functionName: 'hasRole',
                 args: [RoleIds.COMMUNITY, account.address]
-            }) as boolean;
-
-            let registerTx: Hex | undefined;
-
+            });
+            let registerTx;
             if (hasRole) {
                 console.log(`   ℹ️  Account already has COMMUNITY role. Skipping registration.`);
-            } else {
+            }
+            else {
                 // 2. Check GToken Allowance and Balance
                 if (usedAddresses.gToken && usedAddresses.gTokenStaking) {
                     console.log(`   💰 Checking GToken allowance...`);
@@ -132,19 +53,16 @@ export function createCommunityClient({
                         abi: erc20Abi,
                         functionName: 'balanceOf',
                         args: [account.address]
-                    }) as bigint;
-
+                    });
                     if (balance < 50000000000000000000n) { // 50 GT assumption, should ideally check minStake
-                         console.warn(`   ⚠️ Warning: Low GToken balance (${balance}). Registration may fail if minStake > balance.`);
+                        console.warn(`   ⚠️ Warning: Low GToken balance (${balance}). Registration may fail if minStake > balance.`);
                     }
-
                     const allowance = await client.readContract({
                         address: usedAddresses.gToken,
                         abi: erc20Abi,
                         functionName: 'allowance',
                         args: [account.address, usedAddresses.gTokenStaking]
-                    }) as bigint;
-
+                    });
                     if (allowance < 50000000000000000000n) {
                         console.log(`   🔓 Approving GToken for Staking...`);
                         const approveTx = await client.writeContract({
@@ -158,7 +76,6 @@ export function createCommunityClient({
                         await client.waitForTransactionReceipt({ hash: approveTx });
                     }
                 }
-
                 // Register community role
                 console.log(`   📤 Registering community role...`);
                 try {
@@ -169,31 +86,30 @@ export function createCommunityClient({
                         account: account
                     });
                     console.log(`   ✅ Community registered: ${registerTx}`);
-                } catch (e: any) {
-                     // Check for RoleAlreadyGranted (just in case hasRole returned false but race condition or cache)
-                     const isRoleError = e.message?.includes('RoleAlreadyGranted') || 
-                                        (e.cause as any)?.data?.errorName === 'RoleAlreadyGranted' ||
-                                        (e as any).name === 'RoleAlreadyGranted' || 
-                                        (e as any).name === 'RoleAlreadyGranted';
-
+                }
+                catch (e) {
+                    // Check for RoleAlreadyGranted (just in case hasRole returned false but race condition or cache)
+                    const isRoleError = e.message?.includes('RoleAlreadyGranted') ||
+                        e.cause?.data?.errorName === 'RoleAlreadyGranted' ||
+                        e.name === 'RoleAlreadyGranted' ||
+                        e.name === 'RoleAlreadyGranted';
                     if (isRoleError) {
                         console.log(`   ℹ️  Role already granted (caught in tx). Skipping.`);
-                    } else {
+                    }
+                    else {
                         throw e;
                     }
                 }
             }
-
             // Deploy xPNTs token if factory is available
-            let tokenAddress: Address = '0x0000000000000000000000000000000000000000' as Address;
-            const txs: Hex[] = [];
-            if (registerTx) txs.push(registerTx);
-
+            let tokenAddress = '0x0000000000000000000000000000000000000000';
+            const txs = [];
+            if (registerTx)
+                txs.push(registerTx);
             if (usedAddresses.xPNTsFactory) {
                 if (!client.account) {
                     throw new Error("Client account is required for token deployment");
                 }
-
                 // ABI from xPNTsFactory.sol
                 const factoryAbi = [
                     {
@@ -217,8 +133,7 @@ export function createCommunityClient({
                         outputs: [{ name: 'token', type: 'address' }],
                         stateMutability: 'view'
                     }
-                ] as const;
-
+                ];
                 // 1. Check if token already exists
                 try {
                     const existingToken = await client.readContract({
@@ -226,8 +141,7 @@ export function createCommunityClient({
                         abi: factoryAbi,
                         functionName: 'getTokenAddress',
                         args: [account.address]
-                    }) as Address;
-
+                    });
                     if (existingToken && existingToken !== '0x0000000000000000000000000000000000000000') {
                         console.log(`   ℹ️  Found existing token at ${existingToken}`);
                         tokenAddress = existingToken;
@@ -235,12 +149,11 @@ export function createCommunityClient({
                         // If we found it, we don't need to deploy.
                         return { tokenAddress, txs };
                     }
-                } catch (e) {
+                }
+                catch (e) {
                     console.warn(`   ⚠️ Failed to check for existing token:`, e);
                 }
-
                 console.log(`   🏭 Deploying Token via Factory: ${usedAddresses.xPNTsFactory}`);
-                
                 try {
                     // deployxPNTsToken(name, symbol, communityName, communityENS, exchangeRate, paymasterAOA)
                     const { request } = await client.simulateContract({
@@ -248,71 +161,61 @@ export function createCommunityClient({
                         abi: factoryAbi,
                         functionName: 'deployxPNTsToken',
                         args: [
-                            args.tokenName, 
-                            args.tokenSymbol, 
+                            args.tokenName,
+                            args.tokenSymbol,
                             args.name, // communityName
                             args.website || '', // communityENS (mapping website to ENS param for now)
                             1000000000000000000n, // exchangeRate 1e18 (1:1)
                             '0x0000000000000000000000000000000000000000' // paymasterAOA (optional)
                         ],
                         account: client.account
-                    } as any);
-
-                    const deployTx = await client.writeContract(request as any);
+                    });
+                    const deployTx = await client.writeContract(request);
                     console.log(`   📤 Deploy Token Tx: ${deployTx}`);
                     txs.push(deployTx);
-                    
                     const receipt = await client.waitForTransactionReceipt({ hash: deployTx });
-                    
                     // After deployment, fetch the address again
                     const newTokenAddress = await client.readContract({
                         address: usedAddresses.xPNTsFactory,
                         abi: factoryAbi,
                         functionName: 'getTokenAddress',
                         args: [account.address]
-                    }) as Address;
-                    
+                    });
                     if (newTokenAddress) {
                         tokenAddress = newTokenAddress;
                         console.log(`   🪙 Token Deployed: ${tokenAddress}`);
                     }
-
-                } catch (deployError) {
+                }
+                catch (deployError) {
                     console.warn('   ⚠️ Failed to deploy token, but community registered:', deployError);
                 }
             }
-
             return { tokenAddress, txs };
-        } catch (error: any) {
+        }
+        catch (error) {
             console.error('❌ Error in launch():', error);
-            
             // 检查是否是 RoleAlreadyGranted 错误
             const errorMessage = error.message || '';
             const errorData = error.data?.errorName || '';
             const errorString = JSON.stringify(error);
-            
-            if (errorMessage.includes('RoleAlreadyGranted') || 
+            if (errorMessage.includes('RoleAlreadyGranted') ||
                 errorData === 'RoleAlreadyGranted' ||
                 errorString.includes('RoleAlreadyGranted')) {
                 throw new Error(`Account ${account?.address || 'unknown'} already has COMMUNITY role. Please use a different account or exit the role first.`);
             }
-            
             // 检查其他常见错误
             if (errorMessage.includes('InsufficientStake')) {
                 throw new Error('Insufficient stake. Please ensure you have enough GToken staked.');
             }
-            
             if (errorMessage.includes('RoleNotConfigured')) {
                 throw new Error('COMMUNITY role is not configured in the Registry contract.');
             }
-            
             // 重新抛出原始错误
             throw error;
         }
     };
-
     // State query method - check before operations
-    const getCommunityInfo = async (accountAddress: Address) => {
+    const getCommunityInfo = async (accountAddress) => {
         try {
             // 1. Check if account has COMMUNITY role
             const hasRole = await client.readContract({
@@ -320,8 +223,7 @@ export function createCommunityClient({
                 abi: RegistryABI,
                 functionName: 'hasRole',
                 args: [RoleIds.COMMUNITY, accountAddress]
-            }) as boolean;
-
+            });
             if (!hasRole) {
                 return {
                     hasRole: false,
@@ -329,7 +231,6 @@ export function createCommunityClient({
                     communityData: null
                 };
             }
-
             // 2. Get token address from factory
             const factoryAbi = [
                 {
@@ -339,54 +240,51 @@ export function createCommunityClient({
                     stateMutability: 'view',
                     type: 'function'
                 }
-            ] as const;
-
+            ];
             const tokenAddress = await client.readContract({
-                address: usedAddresses.xPNTsFactory!,
+                address: usedAddresses.xPNTsFactory,
                 abi: factoryAbi,
                 functionName: 'getTokenAddress',
                 args: [accountAddress]
-            }) as Address;
-
+            });
             // 3. Get community metadata from Registry
-        const metadata = await client.readContract({
-            address: usedAddresses.registry,
-            abi: RegistryABI,
-            functionName: 'roleMetadata',
-            args: [RoleIds.COMMUNITY, accountAddress]
-        }) as Hex;
-
-        let communityData = {
-            name: 'Community',
-            ensName: '',
-            website: '',
-            description: '',
-            logoURI: ''
-        };
-
-        if (metadata && metadata !== '0x') {
-            try {
-                // RoleMetadata is encoded as CommunityRoleData struct:
-                // (string name, string ensName, string website, string description, string logoURI, uint256 stakeAmount)
-                const decoded = RoleDataFactory.decodeCommunity(metadata);
-                communityData = {
-                    name: decoded.name || 'Community',
-                    ensName: decoded.ensName || '',
-                    website: decoded.website || '',
-                    description: decoded.description || '',
-                    logoURI: decoded.logoURI || ''
-                };
-            } catch (e) {
-                console.warn('   ⚠️ Failed to decode community metadata:', e);
+            const metadata = await client.readContract({
+                address: usedAddresses.registry,
+                abi: RegistryABI,
+                functionName: 'roleMetadata',
+                args: [RoleIds.COMMUNITY, accountAddress]
+            });
+            let communityData = {
+                name: 'Community',
+                ensName: '',
+                website: '',
+                description: '',
+                logoURI: ''
+            };
+            if (metadata && metadata !== '0x') {
+                try {
+                    // RoleMetadata is encoded as CommunityRoleData struct:
+                    // (string name, string ensName, string website, string description, string logoURI, uint256 stakeAmount)
+                    const decoded = RoleDataFactory.decodeCommunity(metadata);
+                    communityData = {
+                        name: decoded.name || 'Community',
+                        ensName: decoded.ensName || '',
+                        website: decoded.website || '',
+                        description: decoded.description || '',
+                        logoURI: decoded.logoURI || ''
+                    };
+                }
+                catch (e) {
+                    console.warn('   ⚠️ Failed to decode community metadata:', e);
+                }
             }
+            return {
+                hasRole: true,
+                tokenAddress: (tokenAddress && tokenAddress !== '0x0000000000000000000000000000000000000000') ? tokenAddress : null,
+                communityData: (metadata && metadata !== '0x') ? communityData : null
+            };
         }
-
-        return {
-            hasRole: true,
-            tokenAddress: (tokenAddress && tokenAddress !== '0x0000000000000000000000000000000000000000') ? tokenAddress : null,
-            communityData: (metadata && metadata !== '0x') ? communityData : null
-        };
-    } catch (error) {
+        catch (error) {
             console.error('Error fetching community info:', error);
             return {
                 hasRole: false,
@@ -395,9 +293,8 @@ export function createCommunityClient({
             };
         }
     };
-
-    return Object.assign(client, registryActionsObj, sbtActionsObj, { 
+    return Object.assign(client, registryActionsObj, sbtActionsObj, {
         launch,
         getCommunityInfo
-    }) as unknown as CommunityClient;
+    });
 }

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

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