@aastar/sdk 0.16.22 → 0.17.0

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 {};

package/dist/clients/operator.test.js

@@ -1,139 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createOperatorClient } from './operator.js';
-import { mainnet } from 'viem/chains';
-import { http, keccak256, stringToBytes } from 'viem';
-vi.mock('@aastar/core', async () => {
-    const actual = await vi.importActual('@aastar/core');
-    return {
-        ...actual,
-        registryActions: vi.fn(() => vi.fn(() => ({
-            registryHasRole: vi.fn().mockResolvedValue(false),
-            registryRegisterRoleSelf: vi.fn().mockResolvedValue('0xhash')
-        }))),
-        stakingActions: vi.fn(() => vi.fn(() => ({
-        // any staking methods if needed
-        }))),
-        superPaymasterActions: vi.fn(() => vi.fn(() => ({
-            superPaymasterDepositFor: vi.fn().mockResolvedValue('0xhash'),
-            superPaymasterOperators: vi.fn().mockResolvedValue([1000n, 1000n, true, false]),
-            superPaymasterGetDeposit: vi.fn().mockResolvedValue(555n)
-        }))),
-        paymasterV4Actions: vi.fn(() => vi.fn(() => ({
-        // pmv4 methods
-        }))),
-        tokenActions: vi.fn(() => vi.fn(() => ({
-            tokenApprove: vi.fn().mockResolvedValue('0xhash')
-        }))),
-    };
-});
-describe('OperatorClient', () => {
-    const MOCK_ADDR = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-    it('should create operator client', () => {
-        const client = createOperatorClient({ chain: mainnet, transport: http() });
-        expect(client.setup).toBeDefined();
-    });
-    describe('onboardFully', () => {
-        it('should complete onboarding flow', async () => {
-            const client = createOperatorClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR }
-            });
-            // Mock base client methods
-            client.readContract = vi.fn().mockResolvedValue([0n, 0n, 0n]);
-            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({ logs: [] });
-            const results = await client.onboardFully({
-                stakeAmount: 100n,
-                depositAmount: 200n,
-                roleId: keccak256(stringToBytes('PAYMASTER_SUPER'))
-            });
-            expect(results).toHaveLength(3);
-            expect(client.tokenApprove).toHaveBeenCalled();
-            expect(client.registryRegisterRoleSelf).toHaveBeenCalled();
-            expect(client.superPaymasterDepositFor).toHaveBeenCalled();
-        });
-    });
-    describe('Advanced Setup', () => {
-        it('should call configureOperator', async () => {
-            const client = createOperatorClient({ chain: mainnet, transport: http() });
-            client.configureOperator = vi.fn().mockResolvedValue('0xhash');
-            const hash = await client.configureOperator({
-                xPNTsToken: MOCK_ADDR,
-                treasury: MOCK_ADDR,
-                exchangeRate: 100n
-            });
-            expect(hash).toBe('0xhash');
-        });
-        it('should onboard to Super Paymaster', async () => {
-            const client = createOperatorClient({
-                chain: mainnet,
-                transport: http(),
-                account: { address: MOCK_ADDR }
-            });
-            client.onboardFully = vi.fn().mockResolvedValue([]);
-            // onboardToSuperPaymaster is an internal action alias in OperatorClient
-            await client.onboardToSuperPaymaster({ stakeAmount: 100n, depositAmount: 200n, roleId: '0x1' });
-            expect(client.onboardFully).toHaveBeenCalled();
-        });
-        it('should deploy PaymasterV4', async () => {
-            const client = createOperatorClient({ chain: mainnet, transport: http(), account: { address: MOCK_ADDR } });
-            client.writeContract = vi.fn().mockResolvedValue('0xdeployhash');
-            client.waitForTransactionReceipt = vi.fn().mockResolvedValue({});
-            const hash = await client.deployPaymasterV4({ version: 'v4.2' });
-            expect(hash).toBe('0xdeployhash');
-        });
-        it('should validate inputs in configureOperator', async () => {
-            const opClient = createOperatorClient({
-                account: { address: MOCK_ADDR },
-                chain: mainnet,
-                transport: http()
-            });
-            // No need to mock internal configureOperator for validation testing 
-            // as validation happens before internal call.
-            await expect(opClient.configureOperator({
-                xPNTsToken: '0xInvalid',
-                treasury: '0x123',
-                exchangeRate: 100n
-            })).rejects.toThrow('xPNTs Token must be a valid Ethereum address');
-            await expect(opClient.configureOperator({
-                xPNTsToken: MOCK_ADDR,
-                treasury: '0xInvalid',
-                exchangeRate: 100n
-            })).rejects.toThrow('Treasury must be a valid Ethereum address');
-        });
-        it('should check readiness', async () => {
-            const opClient = createOperatorClient({
-                account: { address: MOCK_ADDR },
-                chain: mainnet,
-                transport: http()
-            });
-            // Global mock for registryActions.hasRole returns false
-            // Global mock for superPaymasterActions.operators returns [1000n, 1000n, true, false]
-            const status = await opClient.checkReadiness();
-            expect(status.isRegistered).toBe(false); // mocked val
-            expect(status.isConfigured).toBe(true); // mocked val (index 2)
-            expect(status.collateralBalance).toBe(1000n); // mocked val (index 0)
-        });
-    });
-    describe('Operator Status and Queries', () => {
-        it('should get operator status', async () => {
-            const client = createOperatorClient({ chain: mainnet, transport: http() });
-            client.readContract = vi.fn()
-                .mockResolvedValueOnce(true) // hasRole
-                .mockResolvedValueOnce([1000n, 100n, true, false, 0n, 0n, MOCK_ADDR]); // operator data
-            const status = await client.getOperatorStatus(MOCK_ADDR);
-            expect(status.type).toBe('super');
-            expect(status.superPaymaster?.isConfigured).toBe(true);
-        });
-        it('should check if address is operator', async () => {
-            const client = createOperatorClient({ chain: mainnet, transport: http() });
-            const result = await client.isOperator(MOCK_ADDR);
-            expect(result).toBe(true); // from mocked operators
-        });
-        it('should get deposit details', async () => {
-            const client = createOperatorClient({ chain: mainnet, transport: http() });
-            const details = await client.getDepositDetails();
-            expect(details.deposit).toBe(555n); // from mocked getDeposit
-        });
-    });
-});