@aastar/sdk 0.18.0 → 0.20.2

package/dist/clients/endUser.d.ts

@@ -1,77 +0,0 @@
-import { type Client, type Transport, type Chain, type Account, type PublicActions, type WalletActions, type Address, type Hex, type Hash } from 'viem';
-import { type RegistryActions, type SBTActions, type SuperPaymasterActions, type PaymasterActions } from '@aastar/core';
-export type EndUserClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SBTActions & SuperPaymasterActions & PaymasterActions & {
-    /**
-     * High-level API: Onboard user to community with automatic funding
-     */
-    onboard: (args: {
-        community: Address;
-        roleId: Hex;
-        roleData: Hex;
-    }) => Promise<{
-        tx: Hash;
-        sbtId: bigint;
-    }>;
-    /**
-     * Orchestrates the user joining a community and activating gas credit flow:
-     * 1. Mint SBT for the community (Register ENDUSER role)
-     * 2. Verify Credit is active (Reputation check)
-     */
-    joinAndActivate: (args: {
-        community: Address;
-        roleId: Hex;
-        roleData?: Hex;
-    }) => Promise<{
-        tx: Hash;
-        sbtId: bigint;
-        initialCredit: bigint;
-    }>;
-    /**
-     * Executes a gasless transaction via SuperPaymaster.
-     */
-    executeGasless: (args: {
-        target: Address;
-        data: Hex;
-        value?: bigint;
-        operator: Address;
-    }) => Promise<Hash>;
-    /**
-     * Check if the user meets the requirements to join a community (stake, sbt, etc.)
-     */
-    checkJoinRequirements: (address?: Address) => Promise<{
-        hasEnoughGToken: boolean;
-        hasSBT: boolean;
-        missingRequirements: string[];
-    }>;
-    /**
-     * Predict or deploy a SimpleAccount (ERC-4337)
-     */
-    deploySmartAccount: (params: {
-        owner: Address;
-        salt?: bigint;
-        fundWithETH?: bigint;
-    }) => Promise<{
-        accountAddress: Address;
-        deployTxHash: Hash;
-        isDeployed: boolean;
-    }>;
-    /**
-     * Predict the address of a SimpleAccount without deploying
-     */
-    createSmartAccount: (params: {
-        owner: Address;
-        salt?: bigint;
-    }) => Promise<{
-        accountAddress: Address;
-        initCode: Hex;
-        isDeployed: boolean;
-    }>;
-};
-export declare function createEndUserClient({ chain, transport, account, addresses }: {
-    chain: Chain;
-    transport: Transport;
-    account?: Account;
-    addresses?: {
-        [key: string]: Address;
-    };
-}): EndUserClient;

package/dist/clients/endUser.js

@@ -1,298 +0,0 @@
-import { createClient, publicActions, walletActions, parseAbi } from 'viem';
-import { registryActions, sbtActions, superPaymasterActions, paymasterActions, CORE_ADDRESSES, TOKEN_ADDRESSES, TEST_ACCOUNT_ADDRESSES, RegistryABI } from '@aastar/core';
-export function createEndUserClient({ chain, transport, account, addresses }) {
-    const client = createClient({
-        chain,
-        transport,
-        account
-    })
-        .extend(publicActions)
-        .extend(walletActions);
-    const usedAddresses = { ...CORE_ADDRESSES, ...TOKEN_ADDRESSES, ...TEST_ACCOUNT_ADDRESSES, ...addresses };
-    console.log('   SDK Debug: simpleAccountFactory from usedAddresses:', usedAddresses.simpleAccountFactory);
-    console.log('   SDK Debug: process.env.SIMPLE_ACCOUNT_FACTORY:', process.env.SIMPLE_ACCOUNT_FACTORY);
-    const actions = {
-        ...registryActions(usedAddresses.registry)(client),
-        ...sbtActions(usedAddresses.mySBT)(client),
-        ...superPaymasterActions(usedAddresses.superPaymaster)(client),
-        ...paymasterActions(usedAddresses.paymasterV4)(client)
-    };
-    return Object.assign(client, actions, {
-        async onboard({ community, roleId, roleData }) {
-            console.log('👤 Onboarding user to community...');
-            const result = await this.joinAndActivate({ community, roleId, roleData });
-            console.log(`✅ User onboarded! SBT ID: ${result.sbtId}`);
-            return { tx: result.tx, sbtId: result.sbtId };
-        },
-        async joinAndActivate({ community, roleId, roleData }) {
-            const accountToUse = account;
-            if (!accountToUse)
-                throw new Error("Account required for joinAndActivate");
-            console.log(`   SDK: Joining community ${community}...`);
-            // Registry.registerRoleSelf is now idempotent (modified contract)
-            // First call: Mints SBT + grants role
-            // Subsequent calls: Adds community membership
-            // If roleData not provided, encode EndUserRoleData structure
-            let finalData;
-            if (roleData) {
-                finalData = roleData;
-            }
-            else {
-                // Encode EndUserRoleData: (address account, address community, string avatarURI, string ensName, uint256 stakeAmount)
-                const { encodeAbiParameters } = await import('viem');
-                finalData = encodeAbiParameters([
-                    { name: 'account', type: 'address' },
-                    { name: 'community', type: 'address' },
-                    { name: 'avatarURI', type: 'string' },
-                    { name: 'ensName', type: 'string' },
-                    { name: 'stakeAmount', type: 'uint256' }
-                ], [accountToUse.address, community, '', '', 0n] // Use minimum stake (Registry will use roleConfig.minStake)
-                );
-            }
-            const regTx = await client.writeContract({
-                address: usedAddresses.registry,
-                abi: RegistryABI,
-                functionName: 'registerRoleSelf',
-                args: [roleId, finalData],
-                account: accountToUse,
-                chain
-            });
-            await client.waitForTransactionReceipt({ hash: regTx });
-            // 2. Fetch SBT ID
-            const sbtId = await actions.getUserSBT({ user: accountToUse.address });
-            console.log(`   SDK: User joined. SBT ID: ${sbtId}`);
-            // 3. Fetch Initial Credit for verification
-            let credit = 0n;
-            try {
-                const factoryAbi = parseAbi(['function communityToToken(address) view returns (address)']);
-                const tokenAddress = await client.readContract({
-                    address: usedAddresses.xPNTsFactory,
-                    abi: factoryAbi,
-                    functionName: 'communityToToken',
-                    args: [community]
-                });
-                credit = await actions.getAvailableCredit({
-                    user: client.aaAddress || accountToUse.address,
-                    token: tokenAddress
-                });
-                console.log(`   SDK: Activation complete. Current Credit: ${credit} points.`);
-            }
-            catch (error) {
-                console.log(`   SDK: Credit system not available (${error.message.split('\n')[0]}). Continuing...`);
-            }
-            return {
-                tx: regTx,
-                sbtId,
-                initialCredit: credit
-            };
-        },
-        async executeGasless({ target, data, value = 0n, operator }) {
-            const accountToUse = account;
-            if (!accountToUse)
-                throw new Error("Wallet account required for gasless execution");
-            // 1. Get AA Address (Predict if necessary)
-            const { accountAddress } = await this.createSmartAccount({ owner: accountToUse.address });
-            console.log(`   SDK: Executing gasless via AA ${accountAddress} Sponsored by ${operator}`);
-            // 2. Fetch Nonce from EntryPoint (v0.7 standard)
-            // Note: In v0.7, nonce is managed by EntryPoint, not the account itself
-            let nonce = 0n;
-            try {
-                nonce = await client.readContract({
-                    address: usedAddresses.entryPoint,
-                    abi: [{
-                            type: 'function',
-                            name: 'getNonce',
-                            inputs: [{ type: 'address', name: 'sender' }, { type: 'uint192', name: 'key' }],
-                            outputs: [{ type: 'uint256' }],
-                            stateMutability: 'view'
-                        }],
-                    functionName: 'getNonce',
-                    args: [accountAddress, 0n] // 0 = default nonce key
-                });
-            }
-            catch (e) {
-                console.warn(`   ⚠️  Failed to fetch nonce from EntryPoint, using default 0:`, e.message);
-                // For initial transactions, nonce is always 0
-                nonce = 0n;
-            }
-            // 3. Build CallData (execute(target, value, data))
-            const { encodeFunctionData, concat, pad, keccak256 } = await import('viem');
-            const executeData = encodeFunctionData({
-                abi: [{ type: 'function', name: 'execute', inputs: [{ type: 'address' }, { type: 'uint256' }, { type: 'bytes' }] }],
-                functionName: 'execute',
-                args: [target, value, data]
-            });
-            // 4. Build Gas Limits & Fees (Benchmarked for experiments)
-            const accountGasLimits = concat([
-                pad(`0x${(100000).toString(16)}`, { dir: 'left', size: 16 }), // verification
-                pad(`0x${(100000).toString(16)}`, { dir: 'left', size: 16 }) // call
-            ]);
-            const gasFees = concat([
-                pad(`0x${(2000000000).toString(16)}`, { dir: 'left', size: 16 }), // 2 gwei
-                pad(`0x${(2000000000).toString(16)}`, { dir: 'left', size: 16 }) // 2 gwei
-            ]);
-            // 5. Build PaymasterAndData (v0.7 packed format)
-            const paymasterVerificationGas = 250000n;
-            const paymasterPostOpGas = 50000n;
-            const paymasterAndData = concat([
-                usedAddresses.superPaymaster,
-                pad(`0x${paymasterVerificationGas.toString(16)}`, { dir: 'left', size: 16 }),
-                pad(`0x${paymasterPostOpGas.toString(16)}`, { dir: 'left', size: 16 }),
-                operator
-            ]);
-            // 6. Construct UserOperation v0.7
-            const userOp = {
-                sender: accountAddress,
-                nonce,
-                initCode: '0x',
-                callData: executeData,
-                accountGasLimits,
-                preVerificationGas: 50000n,
-                gasFees,
-                paymasterAndData,
-                signature: '0x'
-            };
-            // 7. Sign UserOp Hash
-            const entryPointAddress = usedAddresses.entryPoint || '0x0000000071727De22E5E9d8BAf0edAc6f37da032';
-            const userOpHash = await client.readContract({
-                address: entryPointAddress,
-                abi: [{
-                        type: 'function',
-                        name: 'getUserOpHash',
-                        inputs: [{
-                                type: 'tuple',
-                                components: [
-                                    { name: 'sender', type: 'address' },
-                                    { name: 'nonce', type: 'uint256' },
-                                    { name: 'initCode', type: 'bytes' },
-                                    { name: 'callData', type: 'bytes' },
-                                    { name: 'accountGasLimits', type: 'bytes32' },
-                                    { name: 'preVerificationGas', type: 'uint256' },
-                                    { name: 'gasFees', type: 'bytes32' },
-                                    { name: 'paymasterAndData', type: 'bytes' },
-                                    { name: 'signature', type: 'bytes' }
-                                ]
-                            }],
-                        outputs: [{ type: 'bytes32' }],
-                        stateMutability: 'view'
-                    }],
-                functionName: 'getUserOpHash',
-                args: [userOp]
-            });
-            const signature = await accountToUse.signMessage({
-                message: { raw: userOpHash }
-            });
-            userOp.signature = signature;
-            // 8. Submit via handleOps
-            console.log(`   SDK: Submitting UserOp ${userOpHash}...`);
-            const tx = await client.writeContract({
-                address: entryPointAddress,
-                abi: [{
-                        type: 'function',
-                        name: 'handleOps',
-                        inputs: [
-                            {
-                                type: 'tuple[]',
-                                components: [
-                                    { name: 'sender', type: 'address' },
-                                    { name: 'nonce', type: 'uint256' },
-                                    { name: 'initCode', type: 'bytes' },
-                                    { name: 'callData', type: 'bytes' },
-                                    { name: 'accountGasLimits', type: 'bytes32' },
-                                    { name: 'preVerificationGas', type: 'uint256' },
-                                    { name: 'gasFees', type: 'bytes32' },
-                                    { name: 'paymasterAndData', type: 'bytes' },
-                                    { name: 'signature', type: 'bytes' }
-                                ]
-                            },
-                            { name: 'beneficiary', type: 'address' }
-                        ],
-                        outputs: [],
-                        stateMutability: 'nonpayable'
-                    }],
-                functionName: 'handleOps',
-                args: [[userOp], accountToUse.address],
-                account,
-                chain
-            });
-            await client.waitForTransactionReceipt({ hash: tx });
-            return tx;
-        },
-        async checkJoinRequirements(address) {
-            const accountToUse = address || account?.address;
-            if (!accountToUse)
-                throw new Error("Account address required for requirement check");
-            const { RequirementChecker } = await import('@aastar/core');
-            const checker = new RequirementChecker(client, usedAddresses);
-            // Default requirements for standard community joining
-            return await checker.checkRequirements({
-                address: accountToUse,
-                requiredGToken: 440000000000000000n, // 0.44 GT (stake + burn)
-                requireSBT: false
-            });
-        },
-        async createSmartAccount({ owner, salt = 0n }) {
-            const { SimpleAccountFactoryABI } = await import('@aastar/core');
-            const { encodeFunctionData, concat } = await import('viem');
-            let factoryAddress = usedAddresses.simpleAccountFactory;
-            console.log(`   SDK: Using SimpleAccountFactory: ${factoryAddress} (Owner: ${owner}, Salt: ${salt})`);
-            // Fallback to official v0.7 factory if not provided
-            if (!factoryAddress || factoryAddress === '0x0000000000000000000000000000000000000000') {
-                console.warn("   ⚠️  SimpleAccountFactory not found in configuration. Using default fallback.");
-                factoryAddress = '0x9406Cc6185a346906296840746125a0E44976454';
-            }
-            const accountAddress = await client.readContract({
-                address: factoryAddress,
-                abi: SimpleAccountFactoryABI,
-                functionName: 'getAddress',
-                args: [owner, salt]
-            });
-            const createAccountData = encodeFunctionData({
-                abi: SimpleAccountFactoryABI,
-                functionName: 'createAccount',
-                args: [owner, salt]
-            });
-            const initCode = concat([factoryAddress, createAccountData]);
-            const byteCode = await client.getBytecode({ address: accountAddress });
-            const isDeployed = byteCode !== undefined && byteCode !== '0x';
-            return { accountAddress, initCode, isDeployed };
-        },
-        async deploySmartAccount({ owner, salt = 0n, fundWithETH = 0n }) {
-            const { accountAddress, isDeployed } = await this.createSmartAccount({ owner, salt });
-            const { formatEther } = await import('viem');
-            let deployHash = '0x0';
-            if (isDeployed) {
-                console.log(`   ℹ️ Account ${accountAddress} already deployed.`);
-            }
-            else {
-                const { SimpleAccountFactoryABI } = await import('@aastar/core');
-                let factoryAddress = usedAddresses.simpleAccountFactory;
-                if (!factoryAddress || factoryAddress === '0x0000000000000000000000000000000000000000') {
-                    factoryAddress = '0x9406Cc6185a346906296840746125a0E44976454';
-                }
-                console.log(`   🏭 Deploying Smart Account for ${owner}...`);
-                deployHash = await client.writeContract({
-                    address: factoryAddress,
-                    abi: SimpleAccountFactoryABI,
-                    functionName: 'createAccount',
-                    args: [owner, salt],
-                    account,
-                    chain
-                });
-                await client.waitForTransactionReceipt({ hash: deployHash });
-                console.log(`   ✅ Deployed at ${accountAddress}`);
-            }
-            if (fundWithETH > 0n) {
-                console.log(`   ⛽ Funding account with ${formatEther(fundWithETH)} ETH...`);
-                const tx = await client.sendTransaction({
-                    to: accountAddress,
-                    value: fundWithETH,
-                    account,
-                    chain
-                });
-                await client.waitForTransactionReceipt({ hash: tx });
-            }
-            return { accountAddress, deployTxHash: deployHash, isDeployed: true };
-        }
-    });
-}

package/dist/clients/operator.d.ts

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

@@ -1,209 +0,0 @@
-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 function createOperatorClient({ chain, transport, account, addresses }) {
-    const client = createClient({
-        chain,
-        transport,
-        account
-    })
-        .extend(publicActions)
-        .extend(walletActions);
-    const usedAddresses = { ...CORE_ADDRESSES, ...TEST_TOKEN_ADDRESSES, ...TEST_ACCOUNT_ADDRESSES, ...addresses };
-    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) {
-            console.log('⚙️ Setting up operator...');
-            const txs = await this._onboardOperator(args);
-            console.log(`✅ Operator setup complete! Transactions: ${txs.length}`);
-            return { txs };
-        },
-        async onboardOperator(args) {
-            return this.onboardFully(args);
-        },
-        async onboardFully(args) {
-            return this._onboardOperator(args);
-        },
-        async deployPaymasterV4({ version = 'v4.1', initData = '0x' } = {}) {
-            console.log(`   SDK: Deploying Paymaster V4 (${version})...`);
-            const tx = await client.writeContract({
-                address: usedAddresses.paymasterFactory,
-                abi: PaymasterFactoryABI,
-                functionName: 'deployPaymaster',
-                args: [version, initData],
-                account,
-                chain
-            });
-            await client.waitForTransactionReceipt({ hash: tx });
-            return tx;
-        },
-        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.readContract({
-                    address: usedAddresses.registry,
-                    abi: RegistryABI,
-                    functionName: 'roleConfigs',
-                    args: [roleId]
-                });
-                const entryBurn = roleConfig[1];
-                const totalStakeNeeded = stakeAmount + entryBurn;
-                console.log(`   SDK: Approving GToken (Stake: ${stakeAmount}, Burn: ${entryBurn})...`);
-                const approveGToken = await client.writeContract({
-                    address: usedAddresses.gToken,
-                    abi: erc20Abi,
-                    functionName: 'approve',
-                    args: [usedAddresses.gTokenStaking, totalStakeNeeded],
-                    account: accountToUse,
-                    chain
-                });
-                await client.waitForTransactionReceipt({ hash: approveGToken });
-                txs.push(approveGToken);
-                // 2. Register Role
-                let data;
-                if (roleData && roleData !== '0x') {
-                    data = roleData;
-                }
-                else {
-                    console.log(`   SDK: Auto-generating roleData for roleId ${roleId}...`);
-                    if (roleId === keccak256(stringToBytes('COMMUNITY'))) {
-                        data = RoleDataFactory.community();
-                    }
-                    else if (roleId === keccak256(stringToBytes('ENDUSER'))) {
-                        data = RoleDataFactory.endUser();
-                    }
-                    else if (roleId === keccak256(stringToBytes('PAYMASTER_SUPER'))) {
-                        data = RoleDataFactory.paymasterSuper();
-                    }
-                    else {
-                        data = RoleDataFactory.paymasterSuper();
-                    }
-                }
-                console.log(`   SDK: Checking if role already granted...`);
-                const hasRoleResult = await client.readContract({
-                    address: usedAddresses.registry,
-                    abi: RegistryABI,
-                    functionName: 'hasRole',
-                    args: [roleId, accountToUse.address]
-                });
-                if (hasRoleResult) {
-                    console.log(`   ℹ️  Role already granted, skipping registration`);
-                }
-                else {
-                    console.log(`   SDK: Registering role ${roleId}...`);
-                    const registerTx = await actions.registerRoleSelf({
-                        roleId,
-                        data,
-                        account: accountToUse
-                    });
-                    await client.waitForTransactionReceipt({ hash: registerTx });
-                    txs.push(registerTx);
-                }
-                if (depositAmount > 0n) {
-                    console.log('   SDK: Depositing aPNTs via depositFor...');
-                    const depositTx = await client.writeContract({
-                        address: usedAddresses.superPaymaster,
-                        abi: parseAbi(['function depositFor(address targetOperator, uint256 amount) external']),
-                        functionName: 'depositFor',
-                        args: [accountToUse.address, depositAmount],
-                        account: accountToUse,
-                        chain
-                    });
-                    await client.waitForTransactionReceipt({ hash: depositTx });
-                    txs.push(depositTx);
-                }
-                return txs;
-            }
-            catch (error) {
-                const decodedMsg = decodeContractError(error);
-                throw decodedMsg ? new Error(`Onboarding Failed: ${decodedMsg}`) : error;
-            }
-        },
-        async onboardToSuperPaymaster(args) {
-            return this.onboardOperator(args);
-        },
-        async configureOperator({ xPNTsToken, treasury, exchangeRate, account: accountOverride }) {
-            const tx = await spActions.configureOperator({
-                xPNTsToken,
-                opTreasury: treasury,
-                exchangeRate,
-                account: accountOverride || account
-            });
-            await client.waitForTransactionReceipt({ hash: tx });
-            return tx;
-        },
-        async getOperatorStatus(accountAddress) {
-            try {
-                const hasRole = await client.readContract({
-                    address: usedAddresses.registry,
-                    abi: RegistryABI,
-                    functionName: 'hasRole',
-                    args: [keccak256(stringToBytes('PAYMASTER_SUPER')), accountAddress]
-                });
-                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,
-                        abi: pmAbi,
-                        functionName: 'operators',
-                        args: [accountAddress]
-                    });
-                    if (operatorData && operatorData[2]) { // isConfigured
-                        operatorType = 'super';
-                        superPaymasterInfo = {
-                            hasRole: true,
-                            isConfigured: true,
-                            balance: operatorData[0],
-                            exchangeRate: operatorData[1],
-                            treasury: operatorData[6]
-                        };
-                    }
-                }
-                // 检查 Paymaster V4 (Direct)
-                if (usedAddresses.paymasterFactory && usedAddresses.paymasterFactory !== '0x0000000000000000000000000000000000000000') {
-                    try {
-                        const factoryAbi = parseAbi(['function getPaymasterByOperator(address) view returns (address)']);
-                        const pmAddr = await client.readContract({
-                            address: usedAddresses.paymasterFactory,
-                            abi: factoryAbi,
-                            functionName: 'getPaymasterByOperator',
-                            args: [accountAddress]
-                        });
-                        if (pmAddr !== '0x0000000000000000000000000000000000000000') {
-                            operatorType = operatorType || 'v4';
-                            paymasterV4Info = {
-                                address: pmAddr,
-                                balance: await client.getBalance({ address: pmAddr })
-                            };
-                        }
-                    }
-                    catch (e) {
-                        console.warn(`   ⚠️ Failed to fetch V4 info from factory ${usedAddresses.paymasterFactory}:`, e);
-                    }
-                }
-                return { type: operatorType, superPaymaster: superPaymasterInfo, paymasterV4: paymasterV4Info };
-            }
-            catch (error) {
-                console.error('Error in getOperatorStatus:', error);
-                return { type: null, superPaymaster: null, paymasterV4: null };
-            }
-        }
-    };
-    return Object.assign(client, actions);
-}

package/dist/errors/decoder.d.ts

@@ -1,6 +0,0 @@
-export declare const CustomErrors: {
-    readonly RoleNotConfigured: "RoleNotConfigured(bytes32,bool)";
-    readonly RoleAlreadyGranted: "RoleAlreadyGranted(bytes32,address)";
-    readonly InsufficientStake: "InsufficientStake(uint256,uint256)";
-};
-export declare function decodeContractError(error: any): string | null;