@aastar/sdk 0.18.0 → 0.20.2

package/dist/operator.d.ts

@@ -0,0 +1 @@
+export * from '@aastar/operator';

package/dist/operator.js

@@ -0,0 +1,6 @@
+export { OperatorLifecycle, PaymasterOperatorClient, ProposalState, ProtocolClient } from './chunk-O3Y7II3B.js';
+import './chunk-ZSSNU3UF.js';
+import './chunk-DSZ372PH.js';
+import './chunk-PZ5AY32C.js';
+//# sourceMappingURL=operator.js.map
+//# sourceMappingURL=operator.js.map

package/dist/operator.js.map

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

package/dist/paymaster.d.ts

@@ -0,0 +1 @@
+export * from '@aastar/paymaster';

package/dist/paymaster.js

@@ -0,0 +1,6 @@
+export { PaymasterClient, PaymasterManager, PaymasterOperator, SuperPaymasterAdminClient, SuperPaymasterClient, buildPaymasterData, buildSuperPaymasterData, checkEligibility, formatUserOpV07, getPaymasterV4Middleware, getSuperPaymasterMiddleware, getUserOpHashV07, tuneGasLimit } from './chunk-MPOMWT2J.js';
+import './chunk-ZSSNU3UF.js';
+import './chunk-DSZ372PH.js';
+import './chunk-PZ5AY32C.js';
+//# sourceMappingURL=paymaster.js.map
+//# sourceMappingURL=paymaster.js.map

package/dist/paymaster.js.map

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

package/dist/tokens.d.ts

@@ -0,0 +1 @@
+export * from '@aastar/tokens';

package/dist/tokens.js

@@ -0,0 +1,6 @@
+export { FinanceClient } from './chunk-PCLPYRTX.js';
+import './chunk-ZSSNU3UF.js';
+import './chunk-DSZ372PH.js';
+import './chunk-PZ5AY32C.js';
+//# sourceMappingURL=tokens.js.map
+//# sourceMappingURL=tokens.js.map

package/dist/tokens.js.map

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

package/dist/x402.d.ts

@@ -0,0 +1 @@
+export * from '@aastar/x402';

package/dist/x402.js

@@ -0,0 +1,6 @@
+export { EIP3009_TYPES, FacilitatorClient, GTOKEN_EIP712_DOMAIN, HEADER_PAYMENT_REQUIRED, HEADER_PAYMENT_RESPONSE, HEADER_PAYMENT_SIGNATURE, HEADER_V1_PAYMENT, HEADER_V1_PAYMENT_RESPONSE, X402Client, decodePaymentPayload, decodePaymentRequired, decodeSettleResponse, encodePaymentPayload, encodePaymentRequired, encodeSettleResponse, extractPaymentRequired, extractSettleResponse, generateNonce, getEIP3009Domain, signCancelAuthorization, signGTokenTransferWithAuthorization, signReceiveWithAuthorization, signTransferWithAuthorization } from './chunk-XFI3AK32.js';
+import './chunk-ZSSNU3UF.js';
+import './chunk-DSZ372PH.js';
+import './chunk-PZ5AY32C.js';
+//# sourceMappingURL=x402.js.map
+//# sourceMappingURL=x402.js.map

package/dist/x402.js.map

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

package/package.json

@@ -1,39 +1,108 @@
 {
   "name": "@aastar/sdk",
-  "version": "0.18.0",
-  "description": "AAStar SDK - The all-in-one package for Mycelium Network",
+  "version": "0.20.2",
+  "description": "AAStar SDK - the all-in-one package for Mycelium Network (single bundled package; subpaths preserve the module structure)",
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
   "license": "MIT",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
+    },
+    "./account": {
+      "types": "./dist/account.d.ts",
+      "import": "./dist/account.js"
+    },
+    "./paymaster": {
+      "types": "./dist/paymaster.d.ts",
+      "import": "./dist/paymaster.js"
+    },
+    "./identity": {
+      "types": "./dist/identity.d.ts",
+      "import": "./dist/identity.js"
+    },
+    "./tokens": {
+      "types": "./dist/tokens.d.ts",
+      "import": "./dist/tokens.js"
+    },
+    "./dapp": {
+      "types": "./dist/dapp.d.ts",
+      "import": "./dist/dapp.js"
+    },
+    "./x402": {
+      "types": "./dist/x402.d.ts",
+      "import": "./dist/x402.js"
+    },
+    "./channel": {
+      "types": "./dist/channel.d.ts",
+      "import": "./dist/channel.js"
+    },
+    "./enduser": {
+      "types": "./dist/enduser.d.ts",
+      "import": "./dist/enduser.js"
+    },
+    "./operator": {
+      "types": "./dist/operator.d.ts",
+      "import": "./dist/operator.js"
+    },
+    "./admin": {
+      "types": "./dist/admin.d.ts",
+      "import": "./dist/admin.js"
+    },
+    "./airaccount": {
+      "types": "./dist/airaccount.d.ts",
+      "import": "./dist/airaccount.js"
+    }
+  },
   "files": [
     "dist"
   ],
   "dependencies": {
     "viem": "2.43.3",
-    "@aastar/core": "0.18.0",
-    "@aastar/dapp": "0.18.0",
-    "@aastar/account": "0.18.0",
-    "@aastar/paymaster": "0.18.0",
-    "@aastar/identity": "0.18.0",
-    "@aastar/enduser": "0.18.0",
-    "@aastar/tokens": "0.18.0",
-    "@aastar/operator": "0.18.0",
-    "@aastar/admin": "0.18.0",
-    "@aastar/airaccount": "0.18.0",
-    "@aastar/x402": "0.18.0",
-    "@aastar/channel": "0.18.0"
+    "ethers": "^6.0.0",
+    "@simplewebauthn/browser": "^13.2.2",
+    "axios": "^1.12.2"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "typescript": "5.7.2"
+    "tsup": "^8.0.0",
+    "typescript": "5.7.2",
+    "@aastar/account": "0.20.1",
+    "@aastar/core": "0.20.1",
+    "@aastar/dapp": "0.20.1",
+    "@aastar/paymaster": "0.20.1",
+    "@aastar/identity": "0.20.1",
+    "@aastar/enduser": "0.20.1",
+    "@aastar/operator": "0.20.1",
+    "@aastar/admin": "0.20.1",
+    "@aastar/airaccount": "0.20.1",
+    "@aastar/x402": "0.20.1",
+    "@aastar/tokens": "0.20.1",
+    "@aastar/channel": "0.20.1"
   },
   "scripts": {
-    "clean": "find src -name '*.js' -o -name '*.d.ts' -o -name '*.map' | xargs rm -f",
-    "prebuild": "pnpm clean",
-    "build": "tsc",
+    "build": "tsup",
     "example:local": "tsx examples/regression_test.ts",
     "test": "vitest run"
   }

package/dist/clients/ExperimentClient.d.ts

@@ -1,34 +0,0 @@
-import { Hash } from 'viem';
-export interface ExperimentRecord {
-    id: string;
-    scenario: string;
-    group: 'EOA' | 'AA' | 'SuperPaymaster';
-    txHash: string;
-    gasUsed: bigint;
-    gasPrice: bigint;
-    costETH: string;
-    status: 'Success' | 'Failed';
-    timestamp: number;
-    meta?: any;
-}
-/**
- * ExperimentClient: Business-layer tool for measuring and recording execution metrics
- */
-export declare class ExperimentClient {
-    private records;
-    private scenarioId;
-    private group;
-    constructor(scenarioId: string, group: 'EOA' | 'AA' | 'SuperPaymaster');
-    /**
-     * Record a transaction result
-     */
-    recordTx(txHash: Hash, receipt: {
-        gasUsed: any;
-        effectiveGasPrice: any;
-    }, status: 'Success' | 'Failed', meta?: any): ExperimentRecord;
-    /**
-     * Measure an async task (transaction) automatically
-     */
-    measureTx(taskName: string, txPromise: Promise<Hash>, publicClient: any): Promise<Hash>;
-    getRecords(): ExperimentRecord[];
-}

package/dist/clients/ExperimentClient.js

@@ -1,58 +0,0 @@
-import { formatEther } from 'viem';
-/**
- * ExperimentClient: Business-layer tool for measuring and recording execution metrics
- */
-export class ExperimentClient {
-    records = [];
-    scenarioId;
-    group;
-    constructor(scenarioId, group) {
-        this.scenarioId = scenarioId;
-        this.group = group;
-    }
-    /**
-     * Record a transaction result
-     */
-    recordTx(txHash, receipt, status, meta) {
-        const gasUsed = BigInt(receipt.gasUsed || 0);
-        const gasPrice = BigInt(receipt.effectiveGasPrice || 0);
-        const costBN = gasUsed * gasPrice;
-        const record = {
-            id: `${Date.now()}-${Math.floor(Math.random() * 1000)}`,
-            scenario: this.scenarioId,
-            group: this.group,
-            txHash: txHash,
-            gasUsed: gasUsed,
-            gasPrice: gasPrice,
-            costETH: formatEther(costBN),
-            status: status,
-            timestamp: Date.now(),
-            meta
-        };
-        this.records.push(record);
-        return record;
-    }
-    /**
-     * Measure an async task (transaction) automatically
-     */
-    async measureTx(taskName, txPromise, publicClient) {
-        console.log(`[Experiment: ${this.group}] Executing: ${taskName}...`);
-        const start = Date.now();
-        try {
-            const hash = await txPromise;
-            const receipt = await publicClient.waitForTransactionReceipt({ hash });
-            this.recordTx(hash, receipt, 'Success', { latency: Date.now() - start });
-            const gasUsed = BigInt(receipt.gasUsed || 0);
-            const gasPrice = BigInt(receipt.effectiveGasPrice || 0);
-            console.log(`   ✅ Success! Gas: ${gasUsed} | Cost: ${formatEther(gasUsed * gasPrice)} ETH`);
-            return hash;
-        }
-        catch (e) {
-            console.error(`   ❌ Failed: ${taskName}`, e);
-            throw e;
-        }
-    }
-    getRecords() {
-        return this.records;
-    }
-}

package/dist/clients/admin.d.ts

@@ -1,11 +0,0 @@
-import { type Client, type Transport, type Chain, type Account, type PublicActions, type WalletActions, type Address } from 'viem';
-import { type RegistryActions, type SuperPaymasterActions, type PaymasterActions, type StakingActions, type SBTActions, type DVTActions, type XPNTsFactoryActions, type AggregatorActions } from '@aastar/core';
-export type AdminClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SuperPaymasterActions & PaymasterActions & StakingActions & SBTActions & DVTActions & XPNTsFactoryActions & AggregatorActions;
-export declare function createAdminClient({ chain, transport, account, addresses }: {
-    chain: Chain;
-    transport: Transport;
-    account?: Account;
-    addresses?: {
-        [key: string]: Address;
-    };
-}): AdminClient;

package/dist/clients/admin.js

@@ -1,20 +0,0 @@
-import { createClient, publicActions, walletActions } from 'viem';
-import { registryActions, superPaymasterActions, paymasterActions, stakingActions, sbtActions, dvtActions, xPNTsFactoryActions, aggregatorActions, CORE_ADDRESSES, TOKEN_ADDRESSES } from '@aastar/core';
-const ADDRESS_PLACEHOLDER = '0x0000000000000000000000000000000000000000';
-export function createAdminClient({ chain, transport, account, addresses }) {
-    const baseClient = createClient({ chain, transport, account })
-        .extend(publicActions)
-        .extend(walletActions);
-    const usedAddresses = { ...CORE_ADDRESSES, ...TOKEN_ADDRESSES, ...addresses };
-    const actions = {
-        ...registryActions(usedAddresses.registry)(baseClient),
-        ...superPaymasterActions(usedAddresses.superPaymaster)(baseClient),
-        ...paymasterActions(usedAddresses.paymasterV4)(baseClient),
-        ...stakingActions(usedAddresses.gTokenStaking)(baseClient),
-        ...sbtActions(usedAddresses.mySBT)(baseClient),
-        ...dvtActions(ADDRESS_PLACEHOLDER)(baseClient),
-        ...xPNTsFactoryActions(usedAddresses.xPNTsFactory || '0x')(baseClient),
-        ...aggregatorActions(ADDRESS_PLACEHOLDER)(baseClient),
-    };
-    return Object.assign(baseClient, actions);
-}

package/dist/clients/community.d.ts

@@ -1,40 +0,0 @@
-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/dist/clients/community.js

@@ -1,300 +0,0 @@
-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 function createCommunityClient({ chain, transport, account, addresses }) {
-    const client = createClient({
-        chain,
-        transport,
-        account
-    })
-        .extend(publicActions)
-        .extend(walletActions);
-    const usedAddresses = { ...CORE_ADDRESSES, ...TEST_TOKEN_ADDRESSES, ...addresses };
-    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,
-                ensName: '',
-                website: args.website || '',
-                description: args.description || '',
-                logoURI: args.logoURI || '',
-                stakeAmount: 0n
-            });
-            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]
-            });
-            let registerTx;
-            if (hasRole) {
-                console.log(`   ℹ️  Account already has COMMUNITY role. Skipping registration.`);
-            }
-            else {
-                // 2. Check GToken Allowance and Balance
-                if (usedAddresses.gToken && usedAddresses.gTokenStaking) {
-                    console.log(`   💰 Checking GToken allowance...`);
-                    const balance = await client.readContract({
-                        address: usedAddresses.gToken,
-                        abi: erc20Abi,
-                        functionName: 'balanceOf',
-                        args: [account.address]
-                    });
-                    if (balance < 50000000000000000000n) { // 50 GT assumption, should ideally check minStake
-                        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]
-                    });
-                    if (allowance < 50000000000000000000n) {
-                        console.log(`   🔓 Approving GToken for Staking...`);
-                        const approveTx = await client.writeContract({
-                            address: usedAddresses.gToken,
-                            abi: erc20Abi,
-                            functionName: 'approve',
-                            args: [usedAddresses.gTokenStaking, 115792089237316195423570985008687907853269984665640564039457584007913129639935n], // MaxUint256
-                            account: account
-                        });
-                        console.log(`   ✅ Approved: ${approveTx}`);
-                        await client.waitForTransactionReceipt({ hash: approveTx });
-                    }
-                }
-                // Register community role
-                console.log(`   📤 Registering community role...`);
-                try {
-                    registerTx = await registryActionsObj.registerRole({
-                        roleId: RoleIds.COMMUNITY,
-                        user: account.address,
-                        data: roleData,
-                        account: account
-                    });
-                    console.log(`   ✅ Community registered: ${registerTx}`);
-                }
-                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 {
-                        throw e;
-                    }
-                }
-            }
-            // Deploy xPNTs token if factory is available
-            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 = [
-                    {
-                        type: 'function',
-                        name: 'deployxPNTsToken',
-                        inputs: [
-                            { name: 'name', type: 'string' },
-                            { name: 'symbol', type: 'string' },
-                            { name: 'communityName', type: 'string' },
-                            { name: 'communityENS', type: 'string' },
-                            { name: 'exchangeRate', type: 'uint256' },
-                            { name: 'paymasterAOA', type: 'address' }
-                        ],
-                        outputs: [{ name: 'token', type: 'address' }],
-                        stateMutability: 'nonpayable'
-                    },
-                    {
-                        type: 'function',
-                        name: 'getTokenAddress',
-                        inputs: [{ name: 'community', type: 'address' }],
-                        outputs: [{ name: 'token', type: 'address' }],
-                        stateMutability: 'view'
-                    }
-                ];
-                // 1. Check if token already exists
-                try {
-                    const existingToken = await client.readContract({
-                        address: usedAddresses.xPNTsFactory,
-                        abi: factoryAbi,
-                        functionName: 'getTokenAddress',
-                        args: [account.address]
-                    });
-                    if (existingToken && existingToken !== '0x0000000000000000000000000000000000000000') {
-                        console.log(`   ℹ️  Found existing token at ${existingToken}`);
-                        tokenAddress = existingToken;
-                        // Return early or continue? Logic expects result.
-                        // If we found it, we don't need to deploy.
-                        return { tokenAddress, txs };
-                    }
-                }
-                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({
-                        address: usedAddresses.xPNTsFactory,
-                        abi: factoryAbi,
-                        functionName: 'deployxPNTsToken',
-                        args: [
-                            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
-                    });
-                    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]
-                    });
-                    if (newTokenAddress) {
-                        tokenAddress = newTokenAddress;
-                        console.log(`   🪙 Token Deployed: ${tokenAddress}`);
-                    }
-                }
-                catch (deployError) {
-                    console.warn('   ⚠️ Failed to deploy token, but community registered:', deployError);
-                }
-            }
-            return { tokenAddress, txs };
-        }
-        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') ||
-                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) => {
-        try {
-            // 1. Check if account has COMMUNITY role
-            const hasRole = await client.readContract({
-                address: usedAddresses.registry,
-                abi: RegistryABI,
-                functionName: 'hasRole',
-                args: [RoleIds.COMMUNITY, accountAddress]
-            });
-            if (!hasRole) {
-                return {
-                    hasRole: false,
-                    tokenAddress: null,
-                    communityData: null
-                };
-            }
-            // 2. Get token address from factory
-            const factoryAbi = [
-                {
-                    inputs: [{ name: 'community', type: 'address' }],
-                    name: 'getTokenAddress',
-                    outputs: [{ name: '', type: 'address' }],
-                    stateMutability: 'view',
-                    type: 'function'
-                }
-            ];
-            const tokenAddress = await client.readContract({
-                address: usedAddresses.xPNTsFactory,
-                abi: factoryAbi,
-                functionName: 'getTokenAddress',
-                args: [accountAddress]
-            });
-            // 3. Get community metadata from Registry
-            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
-            };
-        }
-        catch (error) {
-            console.error('Error fetching community info:', error);
-            return {
-                hasRole: false,
-                tokenAddress: null,
-                communityData: null
-            };
-        }
-    };
-    return Object.assign(client, registryActionsObj, sbtActionsObj, {
-        launch,
-        getCommunityInfo
-    });
-}