@aastar/sdk 0.16.23 → 0.17.1

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export * from './clients/ExperimentClient.js';
 export * from '@aastar/enduser';
 export * from '@aastar/operator';
 export * from '@aastar/admin';
+export * as AirAccount from '@aastar/airaccount';
 export * from './utils/roleData.js';
 export * from './utils/keys.js';
 export * from './utils/funding.js';

package/dist/index.js

@@ -15,6 +15,8 @@ export * from './clients/ExperimentClient.js';
 export * from '@aastar/enduser';
 export * from '@aastar/operator';
 export * from '@aastar/admin';
+// Export AirAccount SDK (ERC-4337 + KMS + BLS)
+export * as AirAccount from '@aastar/airaccount';
 // Export Utils & Errors
 export * from './utils/roleData.js';
 export * from './utils/keys.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aastar/sdk",
-  "version": "0.16.23",
+  "version": "0.17.1",
   "description": "AAStar SDK - The all-in-one package for Mycelium Network",
   "type": "module",
   "publishConfig": {
@@ -14,15 +14,16 @@
   ],
   "dependencies": {
     "viem": "2.43.3",
-    "@aastar/core": "0.16.23",
-    "@aastar/dapp": "0.16.23",
-    "@aastar/enduser": "0.16.23",
-    "@aastar/paymaster": "0.16.23",
-    "@aastar/identity": "0.16.23",
-    "@aastar/operator": "0.16.23",
-    "@aastar/tokens": "0.16.23",
-    "@aastar/account": "0.16.23",
-    "@aastar/admin": "0.16.23"
+    "@aastar/account": "0.17.1",
+    "@aastar/enduser": "0.17.1",
+    "@aastar/core": "0.17.1",
+    "@aastar/dapp": "0.17.1",
+    "@aastar/identity": "0.17.1",
+    "@aastar/airaccount": "0.17.1",
+    "@aastar/tokens": "0.17.1",
+    "@aastar/admin": "0.17.1",
+    "@aastar/paymaster": "0.17.1",
+    "@aastar/operator": "0.17.1"
   },
   "devDependencies": {
     "typescript": "5.7.2"

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

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

package/dist/clients/ExperimentClient.test.js

@@ -1,53 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { ExperimentClient } from './ExperimentClient.js';
-describe('ExperimentClient', () => {
-    it('should record transaction result', () => {
-        const client = new ExperimentClient('test-scenario', 'AA');
-        const receipt = { gasUsed: 21000n, effectiveGasPrice: 1000000000n };
-        const record = client.recordTx('0xhash', receipt, 'Success');
-        expect(record.txHash).toBe('0xhash');
-        expect(record.group).toBe('AA');
-        expect(record.status).toBe('Success');
-        expect(record.costETH).toBe('0.000021');
-        expect(client.getRecords()).toHaveLength(1);
-    });
-    it('should measure transaction automatically', async () => {
-        const client = new ExperimentClient('test-scenario', 'SuperPaymaster');
-        const mockPublicClient = {
-            waitForTransactionReceipt: vi.fn().mockResolvedValue({
-                gasUsed: 50000n,
-                effectiveGasPrice: 2000000000n
-            })
-        };
-        const txPromise = Promise.resolve('0xhash');
-        const hash = await client.measureTx('test-task', txPromise, mockPublicClient);
-        expect(hash).toBe('0xhash');
-        expect(client.getRecords()).toHaveLength(1);
-        expect(client.getRecords()[0].status).toBe('Success');
-    });
-    it('should handle failed measureTx', async () => {
-        const client = new ExperimentClient('test-scenario', 'EOA');
-        const txPromise = Promise.reject(new Error('tx failed'));
-        await expect(client.measureTx('test-task', txPromise, {})).rejects.toThrow('tx failed');
-    });
-    it('should handle missing gas fields in receipt', () => {
-        const client = new ExperimentClient('test-scenario', 'AA');
-        const record = client.recordTx('0xhash', {}, 'Success');
-        expect(record.gasUsed).toBe(0n);
-        expect(record.gasPrice).toBe(0n);
-        expect(record.costETH).toBe('0');
-    });
-    it('should record latency in measureTx', async () => {
-        const client = new ExperimentClient('test-scenario', 'AA');
-        const mockPublicClient = {
-            waitForTransactionReceipt: vi.fn().mockResolvedValue({
-                gasUsed: 21000n,
-                effectiveGasPrice: 1000000000n
-            })
-        };
-        await client.measureTx('test', Promise.resolve('0xhash'), mockPublicClient);
-        const record = client.getRecords()[0];
-        expect(record.meta?.latency).toBeDefined();
-        expect(typeof record.meta.latency).toBe('number');
-    });
-});

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

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

package/dist/clients/admin.test.js

@@ -1,79 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createAdminClient } from './admin.js';
-import { mainnet } from 'viem/chains';
-import { http } from 'viem';
-describe('AdminClient', () => {
-    const MOCK_ADDR = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-    it('should create admin client and access modules', () => {
-        const client = createAdminClient({ chain: mainnet, transport: http() });
-        expect(client.system).toBeDefined();
-        expect(client.finance).toBeDefined();
-        expect(client.operators).toBeDefined();
-    });
-    describe('SystemModule', () => {
-        it('should grant role', async () => {
-            const client = createAdminClient({ chain: mainnet, transport: http() });
-            const spy = vi.fn().mockResolvedValue('0xhash');
-            client.registryRegisterRole = spy;
-            const hash = await client.system.grantRole({ roleId: '0x1', user: MOCK_ADDR, data: '0x' });
-            expect(hash).toBe('0xhash');
-            expect(spy).toHaveBeenCalled();
-        });
-        it('should revoke role', async () => {
-            const client = createAdminClient({ chain: mainnet, transport: http() });
-            const spy = vi.fn().mockResolvedValue('0xhash');
-            client.registryUnRegisterRole = spy;
-            const hash = await client.system.revokeRole({ roleId: '0x1', user: MOCK_ADDR });
-            expect(hash).toBe('0xhash');
-            expect(spy).toHaveBeenCalled();
-        });
-        it('should set super paymaster', async () => {
-            const client = createAdminClient({ chain: mainnet, transport: http() });
-            const spy = vi.fn().mockResolvedValue('0xhash');
-            client.registrySetSuperPaymaster = spy;
-            const hash = await client.system.setSuperPaymaster(MOCK_ADDR);
-            expect(hash).toBe('0xhash');
-        });
-    });
-    describe('FinanceModule', () => {
-        it('should deposit', async () => {
-            const client = createAdminClient({ chain: mainnet, transport: http() });
-            const spy = vi.fn().mockResolvedValue('0xhash');
-            client.superPaymasterDeposit = spy;
-            const hash = await client.finance.deposit({ amount: 100n });
-            expect(hash).toBe('0xhash');
-        });
-        it('should depositForOperator', async () => {
-            const client = createAdminClient({ chain: mainnet, transport: http() });
-            const spy = vi.fn().mockResolvedValue('0xhash');
-            client.superPaymasterDepositFor = spy;
-            const hash = await client.finance.depositForOperator({ operator: MOCK_ADDR, amount: 100n });
-            expect(hash).toBe('0xhash');
-        });
-        it('should withdrawTo', async () => {
-            const client = createAdminClient({ chain: mainnet, transport: http() });
-            const spy = vi.fn().mockResolvedValue('0xhash');
-            client.superPaymasterWithdrawTo = spy;
-            const hash = await client.finance.withdrawTo({ to: MOCK_ADDR, amount: 100n });
-            expect(hash).toBe('0xhash');
-        });
-    });
-    describe('OperatorsModule', () => {
-        it('should ban/unban operator', async () => {
-            const client = createAdminClient({ chain: mainnet, transport: http() });
-            const spy = vi.fn().mockResolvedValue('0xhash');
-            client.registryUpdateOperatorBlacklist = spy;
-            await client.operators.ban(MOCK_ADDR);
-            expect(spy).toHaveBeenCalledWith(expect.objectContaining({ statuses: [true] }));
-            await client.operators.unban(MOCK_ADDR);
-            expect(spy).toHaveBeenCalledWith(expect.objectContaining({ statuses: [false] }));
-        });
-        it('should setPaused', async () => {
-            const client = createAdminClient({ chain: mainnet, transport: http() });
-            const spy = vi.fn().mockResolvedValue('0xhash');
-            client.superPaymasterSetOperatorPaused = spy;
-            await client.operators.setPaused(MOCK_ADDR, true);
-            expect(spy).toHaveBeenCalledWith(expect.objectContaining({ paused: true }));
-        });
-    });
-});

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

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

package/dist/clients/clients.test.js

@@ -1,91 +0,0 @@
-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.test.d.ts

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

package/dist/clients/community.test.js

@@ -1,99 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createCommunityClient } from './community.js';
-import { mainnet } from 'viem/chains';
-import { http } from 'viem';
-vi.mock('@aastar/core', async () => {
-    const actual = await vi.importActual('@aastar/core');
-    return {
-        ...actual,
-        registryActions: vi.fn(() => vi.fn(() => ({
-            registerRoleSelf: vi.fn().mockResolvedValue('0xhash'),
-            hasRole: vi.fn(),
-            roleMetadata: vi.fn()
-        }))),
-        sbtActions: vi.fn(() => vi.fn(() => ({
-            getUserSBT: vi.fn().mockResolvedValue(123n)
-        }))),
-        reputationActions: vi.fn(() => vi.fn(() => ({
-            setReputationRule: vi.fn().mockResolvedValue('0xhash')
-        }))),
-    };
-});
-describe('CommunityClient', () => {
-    const MOCK_ADDR = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-    it('should create community client', () => {
-        const client = createCommunityClient({ chain: mainnet, transport: http() });
-        expect(client.launch).toBeDefined();
-    });
-    describe('launch', () => {
-        it('should launch community with token and governance', async () => {
-            const client = createCommunityClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR }
-            });
-            // Mock base client methods
-            client.readContract = vi.fn().mockResolvedValue('0x0000000000000000000000000000000000000000');
-            client.simulateContract = vi.fn().mockResolvedValue({ request: {} });
-            client.writeContract = vi.fn().mockResolvedValue('0xhash');
-            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
-            const result = await client.launch({
-                name: 'Test',
-                tokenName: 'T',
-                tokenSymbol: 'T',
-                governance: { initialReputationRule: true }
-            });
-            expect(result.results.length).toBeGreaterThanOrEqual(2);
-            expect(client.writeContract).toHaveBeenCalled();
-        });
-    });
-    describe('getCommunityInfo', () => {
-        it('should return info for registered community', async () => {
-            const client = createCommunityClient({ chain: mainnet, transport: http() });
-            client.readContract = vi.fn()
-                .mockResolvedValueOnce(true) // hasRole
-                .mockResolvedValueOnce('0xtoken') // getTokenAddress
-                .mockResolvedValueOnce('0x'); // roleMetadata
-            const info = await client.getCommunityInfo(MOCK_ADDR);
-            expect(info.hasRole).toBe(true);
-            expect(info.tokenAddress).toBe('0xtoken');
-        });
-    });
-    describe('Launch', () => {
-        it('should validate launch inputs', async () => {
-            const communityClient = createCommunityClient({ chain: mainnet, transport: http(), account: { address: MOCK_ADDR } });
-            await expect(communityClient.launch({
-                name: '',
-                tokenName: 'T',
-                tokenSymbol: 'T'
-            })).rejects.toThrow('Community Name is required');
-            await expect(communityClient.launch({
-                name: 'Test',
-                tokenName: '',
-                tokenSymbol: 'T'
-            })).rejects.toThrow('Token Name is required');
-            await expect(communityClient.launch({
-                name: 'Test',
-                tokenName: 'Test',
-                tokenSymbol: ''
-            })).rejects.toThrow('Token Symbol is required');
-        });
-        it('should handle registration failure gracefully in launch', async () => {
-            const communityClient = createCommunityClient({ chain: mainnet, transport: http(), account: { address: MOCK_ADDR } });
-            // Mock writeContract failure (Already registered)
-            communityClient.writeContract = vi.fn().mockRejectedValueOnce(new Error('Already registered'));
-            // Mock deployToken to succeed
-            communityClient.readContract = vi.fn().mockResolvedValue('0x0000000000000000000000000000000000000000');
-            communityClient.deployToken = vi.fn().mockResolvedValue('0xtoken');
-            // Mock setGovernance
-            communityClient.setReputationRule = vi.fn().mockResolvedValue('0xrule');
-            communityClient.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
-            await communityClient.launch({
-                name: 'Test',
-                tokenName: 'Test',
-                tokenSymbol: 'TST'
-            });
-            expect(true).toBe(true);
-        });
-    });
-});

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

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

package/dist/clients/endUser.test.js

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createEndUserClient } from './endUser.js';
-import { mainnet } from 'viem/chains';
-import { http, parseEther } from 'viem';
-vi.mock('@aastar/core', async () => {
-    const actual = await vi.importActual('@aastar/core');
-    return {
-        ...actual,
-        registryActions: vi.fn(() => vi.fn(() => ({
-            registryRegisterRoleSelf: vi.fn().mockResolvedValue('0xhash')
-        }))),
-        sbtActions: vi.fn(() => vi.fn(() => ({
-            sbtGetUserSBT: vi.fn().mockResolvedValue(123n)
-        }))),
-        superPaymasterActions: vi.fn(() => vi.fn(() => ({
-            superPaymasterGetAvailableCredit: vi.fn().mockResolvedValue(100n)
-        }))),
-        paymasterV4Actions: vi.fn(() => vi.fn(() => ({
-        // pmv4
-        }))),
-    };
-});
-describe('EndUserClient', () => {
-    const MOCK_ADDR = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-    const MOCK_COMMUNITY = '0x1111111111111111111111111111111111111111';
-    it('should create end user client', () => {
-        const client = createEndUserClient({ chain: mainnet, transport: http() });
-        expect(client.joinAndActivate).toBeDefined();
-    });
-    describe('joinAndActivate', () => {
-        it('should join community and fetch SBT', async () => {
-            const client = createEndUserClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR }
-            });
-            client.readContract = vi.fn().mockResolvedValue('0x0000000000000000000000000000000000000000');
-            client.writeContract = vi.fn().mockResolvedValue('0xhash');
-            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
-            const result = await client.joinAndActivate({ community: MOCK_COMMUNITY, roleId: '0x1' });
-            expect(result.sbtId).toBe(123n);
-        });
-    });
-    describe('executeGasless', () => {
-        it('should execute gasless transaction', async () => {
-            const client = createEndUserClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR, signMessage: vi.fn().mockResolvedValue('0xsignature') }
-            });
-            client.createSmartAccount = vi.fn().mockResolvedValue({ accountAddress: '0xaa', isDeployed: true });
-            client.readContract = vi.fn().mockResolvedValue(0n); // nonce or userOpHash
-            client.getBytecode = vi.fn().mockResolvedValue('0x123');
-            client.writeContract = vi.fn().mockResolvedValue('0xhash');
-            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
-            const result = await client.executeGasless({
-                target: MOCK_COMMUNITY,
-                data: '0x',
-                operator: MOCK_COMMUNITY
-            });
-            expect(result.hash).toBe('0xhash');
-        });
-    });
-    describe('executeGaslessBatch', () => {
-        it('should execute gasless batch', async () => {
-            const client = createEndUserClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR, signMessage: vi.fn().mockResolvedValue('0xsignature') }
-            });
-            client.createSmartAccount = vi.fn().mockResolvedValue({ accountAddress: '0xaa', isDeployed: true });
-            client.readContract = vi.fn().mockResolvedValue(0n);
-            client.getBytecode = vi.fn().mockResolvedValue('0x123');
-            client.writeContract = vi.fn().mockResolvedValue('0xhash');
-            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
-            const result = await client.executeGaslessBatch({
-                targets: [MOCK_COMMUNITY],
-                datas: ['0x'],
-                operator: MOCK_COMMUNITY
-            });
-            expect(result.hash).toBe('0xhash');
-        });
-    });
-    describe('Requirements and Credits', () => {
-        it('should call onboard (alias for joinAndActivate)', async () => {
-            const client = createEndUserClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR }
-            });
-            client.joinAndActivate = vi.fn().mockResolvedValue({ hash: '0xhash', events: [], sbtId: 1n });
-            const result = await client.onboard({ community: MOCK_COMMUNITY, roleId: '0x1', roleData: '0x' });
-            expect(result.sbtId).toBe(1n);
-        });
-        it('should check join requirements', async () => {
-            const client = createEndUserClient({ chain: mainnet, transport: http() });
-            // Mock balance return for GToken balance check >= 0.44 GT
-            client.readContract = vi.fn().mockResolvedValue(1000000000000000000n);
-            const result = await client.checkJoinRequirements(MOCK_ADDR);
-            expect(result.hasEnoughGToken).toBe(true);
-        });
-        it('should get available credit', async () => {
-            const client = createEndUserClient({ chain: mainnet, transport: http() });
-            // getAvailableCredit is part of SuperPaymasterActions which is extended in client
-            const credit = await client.superPaymasterGetAvailableCredit({ operator: MOCK_COMMUNITY, user: MOCK_ADDR });
-            expect(credit).toBe(100n);
-        });
-    });
-    describe('Smart Account Management', () => {
-        it('should create smart account with prediction', async () => {
-            const client = createEndUserClient({ chain: mainnet, transport: http() });
-            client.readContract = vi.fn().mockResolvedValue('0xAccountAddress');
-            client.getBytecode = vi.fn().mockResolvedValue(undefined);
-            const result = await client.createSmartAccount({ owner: MOCK_ADDR, salt: 123n });
-            expect(result.accountAddress).toBe('0xAccountAddress');
-            expect(result.isDeployed).toBe(false);
-            expect(result.initCode).toBeDefined();
-        });
-        it('should detect already deployed smart account', async () => {
-            const client = createEndUserClient({ chain: mainnet, transport: http() });
-            client.readContract = vi.fn().mockResolvedValue('0xDeployedAccount');
-            client.getBytecode = vi.fn().mockResolvedValue('0x123456');
-            const result = await client.createSmartAccount({ owner: MOCK_ADDR });
-            expect(result.isDeployed).toBe(true);
-        });
-        it('should throw error if factory not configured', async () => {
-            const client = createEndUserClient({ chain: mainnet, transport: http(), addresses: { simpleAccountFactory: '0x0000000000000000000000000000000000000000' } });
-            await expect(client.createSmartAccount({ owner: MOCK_ADDR }))
-                .rejects.toThrow('SimpleAccountFactory not found');
-        });
-        it('should deploy new smart account', async () => {
-            const client = createEndUserClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR }
-            });
-            client.createSmartAccount = vi.fn().mockResolvedValue({ accountAddress: '0xNewAccount', isDeployed: false });
-            client.writeContract = vi.fn().mockResolvedValue('0xdeployhash');
-            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
-            client.getBalance = vi.fn().mockResolvedValue(0n);
-            client.sendTransaction = vi.fn().mockResolvedValue('0xfundhash');
-            const result = await client.deploySmartAccount({ owner: MOCK_ADDR, fundWithETH: parseEther('0.1') });
-            expect(result.accountAddress).toBe('0xNewAccount');
-            expect(result.deployTxHash).toBe('0xdeployhash');
-        });
-        it('should skip deploy if already deployed', async () => {
-            const client = createEndUserClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR }
-            });
-            client.createSmartAccount = vi.fn().mockResolvedValue({ accountAddress: '0xExisting', isDeployed: true });
-            client.getBalance = vi.fn().mockResolvedValue(parseEther('1'));
-            const result = await client.deploySmartAccount({ owner: MOCK_ADDR });
-            expect(result.accountAddress).toBe('0xExisting');
-            expect(result.deployTxHash).toBe('0x0');
-        });
-        it('should handle logic when smart account not deployed during batch', async () => {
-            const mockAccount = { address: MOCK_ADDR, signMessage: vi.fn().mockResolvedValue('0xsig') };
-            const client = createEndUserClient({ chain: mainnet, transport: http(), account: mockAccount });
-            // Mock getBytecode to return undefined/0x
-            client.getBytecode = vi.fn().mockResolvedValue('0x'); // Not deployed
-            client.createSmartAccount = vi.fn().mockResolvedValue({ initCode: '0x123' });
-            client.readContract = vi.fn().mockResolvedValue('0xhash');
-            client.writeContract = vi.fn().mockResolvedValue('0xhash');
-            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
-            const results = await client.executeGaslessBatch({
-                targets: [MOCK_ADDR],
-                datas: ['0x'],
-                operator: MOCK_ADDR
-            });
-            expect(client.createSmartAccount).toHaveBeenCalled();
-            expect(results.hash).toBe('0xhash');
-        });
-        it('should handle execution errors in gasless batch', async () => {
-            const mockAccount = { address: MOCK_ADDR, signMessage: vi.fn().mockResolvedValue('0xsig') };
-            const client = createEndUserClient({ chain: mainnet, transport: http(), account: mockAccount });
-            client.getBytecode = vi.fn().mockResolvedValue('0xcode'); // deployed
-            client.readContract = vi.fn().mockResolvedValue('0xhash');
-            client.writeContract = vi.fn().mockRejectedValue(new Error('Contract Reverted'));
-            await expect(client.executeGaslessBatch({
-                targets: [MOCK_ADDR],
-                datas: ['0x'],
-                operator: MOCK_ADDR
-            })).rejects.toThrow('Contract Reverted');
-        });
-    });
-});

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

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