@aastar/enduser 0.16.12 → 0.16.16

package/dist/CommunityClient.d.ts

@@ -49,6 +49,22 @@ export declare class CommunityClient extends BaseClient {
         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
      */

package/dist/CommunityClient.js

@@ -103,6 +103,50 @@ export class CommunityClient extends BaseClient {
             throw error;
         }
     }
+    /**
+     * One-click Setup: Register Community + Deploy Token
+     * Orchestrates the complete community initialization flow.
+     */
+    async setupCommunity(params, options) {
+        const hashes = [];
+        let tokenAddress = '0x0000000000000000000000000000000000000000';
+        // 1. Register as Community (Idempotent check handled inside or by registry)
+        // We should check hasRole first to avoid errors if already registered
+        const registry = registryActions(this.requireRegistry())(this.getStartPublicClient());
+        const ROLE_COMMUNITY = await registry.ROLE_COMMUNITY();
+        const hasRole = await registry.hasRole({ roleId: ROLE_COMMUNITY, user: this.getAddress() });
+        if (!hasRole) {
+            const hReg = await this.registerAsCommunity({
+                name: params.name,
+                ensName: params.website, // Mapping website to ENS param for now as per legacy behavior
+                website: params.website,
+                description: params.description,
+                logoURI: params.logoURI,
+                stakeAmount: params.stakeAmount
+            }, options);
+            hashes.push(hReg);
+        }
+        // 2. Deploy Token (Idempotent check via Factory)
+        if (this.factoryAddress) {
+            const factoryReader = xPNTsFactoryActions(this.factoryAddress)(this.getStartPublicClient());
+            const existingToken = await factoryReader.getTokenAddress({ community: this.getAddress() });
+            if (existingToken && existingToken !== '0x0000000000000000000000000000000000000000') {
+                tokenAddress = existingToken;
+            }
+            else {
+                const hToken = await this.createCommunityToken({
+                    name: params.tokenName,
+                    tokenSymbol: params.tokenSymbol,
+                    description: params.description
+                }, options);
+                hashes.push(hToken);
+                // Note: We can't get the address synchronously without waiting. 
+                // In L3 pattern, we usually return hashes.
+                // The user can fetch token address later using factory.getTokenAddress(community)
+            }
+        }
+        return { tokenAddress, hashes };
+    }
     // ========================================
     // 2. 成员管理
     // ========================================

package/dist/UserClient.d.ts

@@ -8,6 +8,7 @@ export interface UserClientConfig extends ClientConfig {
     gTokenStakingAddress?: Address;
     registryAddress?: Address;
     gTokenAddress?: Address;
+    bundlerClient?: any;
 }
 export declare class UserClient extends BaseClient {
     accountAddress: Address;
@@ -16,6 +17,7 @@ export declare class UserClient extends BaseClient {
     gTokenStakingAddress?: Address;
     registryAddress?: Address;
     gTokenAddress?: Address;
+    bundlerClient?: any;
     constructor(config: UserClientConfig);
     /**
      * Get the nonce of the account from EntryPoint (more reliable for 4337)
@@ -83,5 +85,7 @@ export declare class UserClient extends BaseClient {
         data: Hex;
         paymaster: Address;
         paymasterType: 'V4' | 'Super';
+        operator?: Address;
+        maxRate?: bigint;
     }, options?: TransactionOptions): Promise<Hash>;
 }

package/dist/UserClient.js

@@ -1,7 +1,7 @@
+import { encodeFunctionData } from 'viem';
 import { BaseClient } from '@aastar/core';
 import { accountActions, sbtActions, tokenActions, entryPointActions, stakingActions, registryActions } from '@aastar/core';
-import { bundlerActions, getUserOperationHash } from 'viem/account-abstraction';
-import { encodeFunctionData } from 'viem';
+import { bundlerActions } from 'viem/account-abstraction';
 export class UserClient extends BaseClient {
     accountAddress;
     sbtAddress;
@@ -9,8 +9,10 @@ export class UserClient extends BaseClient {
     gTokenStakingAddress;
     registryAddress;
     gTokenAddress;
+    bundlerClient;
     constructor(config) {
         super(config);
+        this.bundlerClient = config.bundlerClient;
         this.accountAddress = config.accountAddress;
         this.sbtAddress = config.sbtAddress;
         this.entryPointAddress = config.entryPointAddress;
@@ -328,67 +330,29 @@ export class UserClient extends BaseClient {
      */
     async executeGasless(params, options) {
         try {
-            const client = this.client.extend(bundlerActions);
+            const client = this.bundlerClient ? this.bundlerClient.extend(bundlerActions) : this.client.extend(bundlerActions);
             const ep = this.requireEntryPoint();
-            const publicClient = this.getStartPublicClient();
             // 1. Prepare Call Data
             const callData = encodeFunctionData({
                 abi: [{ name: 'execute', type: 'function', inputs: [{ name: 'dest', type: 'address' }, { name: 'value', type: 'uint256' }, { name: 'func', type: 'bytes' }], outputs: [] }],
                 functionName: 'execute',
                 args: [params.target, params.value, params.data]
             });
-            // 2. Prepare Paymaster Data
-            let paymasterAndData = params.paymaster;
-            // Note: In real scenarios, PM V4 or Super might need additional encoded data.
-            // For now, we use the address as the base.
-            // 3. Estimate Gas
-            const sender = this.accountAddress;
-            const nonce = await this.getNonce();
-            const userOpPartial = {
-                sender,
-                nonce,
-                initCode: '0x',
-                callData,
-                paymasterAndData,
-                signature: '0x'
-            };
-            const gasEstimate = await client.estimateUserOperationGas({
-                userOperation: userOpPartial,
-                entryPoint: ep
-            });
-            // 4. Construct Final UserOp 
-            const fees = await publicClient.estimateFeesPerGas();
-            const userOp = {
-                ...userOpPartial,
-                callGasLimit: gasEstimate.callGasLimit,
-                verificationGasLimit: gasEstimate.verificationGasLimit + 50000n,
-                preVerificationGas: gasEstimate.preVerificationGas,
-                maxFeePerGas: fees.maxFeePerGas || fees.gasPrice || 1000000000n,
-                maxPriorityFeePerGas: fees.maxPriorityFeePerGas || 1000000000n
-            };
-            // 5. Sign
-            const chainId = this.client.chain?.id || 31337;
-            const hash = getUserOperationHash({
-                userOperation: userOp,
-                entryPointAddress: ep,
-                entryPointVersion: '0.7',
-                chainId
-            });
-            const signature = await this.client.signMessage({
-                message: { raw: hash },
-                account: this.client.account
-            });
-            const signedUserOp = {
-                ...userOp,
-                signature
-            };
-            // 6. Send
-            return await client.sendUserOperation({
-                userOperation: signedUserOp,
-                entryPoint: ep
+            // 3. Delegate to PaymasterClient for v0.7 Gasless Submission
+            // This ensures we follow the exact same logic as successful demo scripts
+            // We dynamic import to avoid circular dependencies if any
+            const { PaymasterClient: SDKPaymasterClient } = await import('../../paymaster/src/V4/PaymasterClient.js');
+            const txHash = await SDKPaymasterClient.submitGaslessUserOperation(this.client, this.client, // WalletClient acts as signer
+            this.accountAddress, ep, params.paymaster, params.target, // placeholder for token if V4
+            this.bundlerClient?.transport?.url || this.client.transport.url || '', callData, {
+                operator: params.operator,
+                autoEstimate: true, // Let SDK handle estimation & tuning
+                paymasterPostOpGasLimit: 100000n // conservative default
             });
+            return txHash;
         }
         catch (error) {
+            console.error("   ❌ executeGasless Error:", error.message);
             throw error;
         }
     }

package/dist/UserLifecycle.d.ts

@@ -0,0 +1,85 @@
+import { type Address, type Hash, type Hex } from 'viem';
+import { BaseClient, type ClientConfig } from '@aastar/core';
+export interface GaslessConfig {
+    paymasterUrl: string;
+    policy?: 'CREDIT' | 'TOKEN' | 'SPONSORED';
+}
+export interface UserLifecycleConfig extends ClientConfig {
+    accountAddress: Address;
+    registryAddress: Address;
+    sbtAddress: Address;
+    gTokenAddress: Address;
+    gTokenStakingAddress: Address;
+    entryPointAddress: Address;
+    gasless?: GaslessConfig;
+}
+export interface OnboardResult {
+    success: boolean;
+    sbtId?: bigint;
+    txHash?: Hash;
+}
+export 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
+ */
+export declare class UserLifecycle extends BaseClient {
+    accountAddress: Address;
+    registryAddress: Address;
+    sbtAddress: Address;
+    gTokenAddress: Address;
+    gTokenStakingAddress: Address;
+    entryPointAddress: Address;
+    gaslessConfig?: GaslessConfig;
+    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>;
+    /**
+     * Claim a specific SBT Role
+     */
+    claimSBT(roleId: Hex): Promise<Hash>;
+    getMyReputation(): Promise<ReputationData>;
+    getCreditLimit(): Promise<bigint>;
+    /**
+     * Leave community: Unbind assets, Burn SBT, Remove Role
+     */
+    leaveCommunity(community: Address): Promise<Hash>;
+    /**
+     * Exit a specific role in Registry
+     */
+    exitRole(roleId: Hex): Promise<Hash>;
+    /**
+     * Unstake all GTokens from Staking contract
+     */
+    unstakeAll(roleId: Hex): Promise<Hash>;
+}

package/dist/UserLifecycle.js

@@ -0,0 +1,180 @@
+import { parseEther } from 'viem';
+import { BaseClient } from '@aastar/core';
+import { registryActions, sbtActions, stakingActions } from '@aastar/core'; // L2/L1 Actions
+/**
+ * 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
+ */
+export class UserLifecycle extends BaseClient {
+    accountAddress;
+    registryAddress;
+    sbtAddress;
+    gTokenAddress;
+    gTokenStakingAddress;
+    entryPointAddress;
+    gaslessConfig;
+    constructor(config) {
+        super(config);
+        this.accountAddress = config.accountAddress;
+        this.registryAddress = config.registryAddress;
+        this.sbtAddress = config.sbtAddress;
+        this.gTokenAddress = config.gTokenAddress;
+        this.gTokenStakingAddress = config.gTokenStakingAddress;
+        this.entryPointAddress = config.entryPointAddress;
+        this.gaslessConfig = config.gasless;
+    }
+    // ===========================================
+    // 1. Onboarding Phase (Registration)
+    // ===========================================
+    /**
+     * Check if user is eligible to join a community
+     * @param community Address of the community
+     */
+    async checkEligibility(community) {
+        // Validation logic (e.g., check blacklist or whitelist via Registry)
+        const registry = registryActions(this.registryAddress)(this.client);
+        // Placeholder: simplistic check, real logic might involve community specific rules
+        return true;
+    }
+    /**
+     * 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)
+     */
+    async onboard(community, stakeAmount = parseEther('0.4')) {
+        try {
+            const registry = registryActions(this.registryAddress)(this.client);
+            const userClient = await import('./UserClient.js').then(m => new m.UserClient({
+                ...this.config,
+                accountAddress: this.accountAddress,
+                registryAddress: this.registryAddress,
+                gTokenStakingAddress: this.gTokenStakingAddress,
+                gTokenAddress: this.gTokenAddress,
+                sbtAddress: this.sbtAddress
+            }));
+            // Use UserClient's batch execution capability for atomic onboarding
+            const txHash = await userClient.registerAsEndUser(community, stakeAmount);
+            // Post-check: Verify role
+            const hasRole = await registry.hasRole({
+                roleId: await registry.ROLE_ENDUSER(),
+                user: this.accountAddress
+            });
+            return {
+                success: hasRole,
+                txHash
+            };
+        }
+        catch (error) {
+            console.error("Onboarding failed:", error);
+            return { success: false };
+        }
+    }
+    /**
+     * Enable or update Gasless configuration
+     */
+    async enableGasless(config) {
+        this.gaslessConfig = config;
+        // In future: verify paymaster connection here
+    }
+    // ===========================================
+    // 2. Operational Phase (Execute & Interact)
+    // ===========================================
+    /**
+     * Execute a transaction effectively using Gasless configuration if available
+     */
+    async executeGaslessTx(params) {
+        if (!this.gaslessConfig) {
+            throw new Error("Gasless configuration not enabled. Call enableGasless() first.");
+        }
+        const userClient = await import('./UserClient.js').then(m => new m.UserClient({
+            ...this.config,
+            accountAddress: this.accountAddress,
+            // Pass minimal config needed for execution
+            entryPointAddress: this.entryPointAddress,
+            bundlerClient: this.config.bundlerClient
+        }));
+        // Determine Paymaster Type based on policy
+        const paymasterType = this.gaslessConfig.policy === 'CREDIT' ? 'Super' : 'V4';
+        // Note: Real implementation needs to resolve actual Paymaster Address from Registry/Config
+        // This is a placeholder address resolution
+        const registry = registryActions(this.registryAddress)(this.client);
+        const paymasterAddress = await registry.SUPER_PAYMASTER();
+        return await userClient.executeGasless({
+            target: params.target,
+            value: params.value,
+            data: params.data,
+            paymaster: paymasterAddress,
+            paymasterType,
+            operator: params.operator
+        });
+    }
+    /**
+     * Claim a specific SBT Role
+     */
+    async claimSBT(roleId) {
+        const userClient = await import('./UserClient.js').then(m => new m.UserClient({
+            ...this.config,
+            accountAddress: this.accountAddress,
+            sbtAddress: this.sbtAddress
+        }));
+        return await userClient.mintSBT(roleId);
+    }
+    // ===========================================
+    // 3. Query Phase (Info & Stats)
+    // ===========================================
+    async getMyReputation() {
+        const registry = registryActions(this.registryAddress)(this.client);
+        const [score, creditLimit] = await Promise.all([
+            registry.globalReputation({ user: this.accountAddress }),
+            registry.getCreditLimit({ user: this.accountAddress })
+        ]);
+        return {
+            score,
+            level: 0n, // TODO: Add level calculation logic
+            creditLimit
+        };
+    }
+    async getCreditLimit() {
+        const registry = registryActions(this.registryAddress)(this.client);
+        return await registry.getCreditLimit({ user: this.accountAddress });
+    }
+    // ===========================================
+    // 4. Exit Phase (Cleanup)
+    // ===========================================
+    /**
+     * Leave community: Unbind assets, Burn SBT, Remove Role
+     */
+    async leaveCommunity(community) {
+        const sbt = sbtActions(this.sbtAddress)(this.client);
+        // 1. Leave Logic (contracts usually handle burn)
+        return await sbt.leaveCommunity({
+            community,
+            account: this.accountAddress // Self-exit
+        });
+    }
+    /**
+     * Exit a specific role in Registry
+     */
+    async exitRole(roleId) {
+        const registry = registryActions(this.registryAddress)(this.client);
+        return await registry.exitRole({
+            roleId,
+            account: this.accountAddress
+        });
+    }
+    /**
+     * Unstake all GTokens from Staking contract
+     */
+    async unstakeAll(roleId) {
+        const staking = stakingActions(this.gTokenStakingAddress)(this.client);
+        return await staking.unlockAndTransfer({
+            user: this.accountAddress,
+            roleId,
+            account: this.accountAddress
+        });
+    }
+}

package/dist/enduser/src/CommunityClient.d.ts

@@ -0,0 +1,81 @@
+import { type Address, type Hash } from 'viem';
+import { BaseClient, type ClientConfig, type TransactionOptions } from '@aastar/core';
+export interface CommunityClientConfig extends ClientConfig {
+    sbtAddress?: Address;
+    factoryAddress?: Address;
+    reputationAddress?: Address;
+}
+export interface CreateCommunityParams {
+    name: string;
+    tokenSymbol: string;
+    ensName?: string;
+    description?: string;
+}
+export interface CommunityInfo {
+    address: Address;
+}
+/**
+ * Client for Community Managers (`ROLE_COMMUNITY`)
+ */
+export 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>;
+    /**
+     * 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>;
+}