@aastar/sdk 0.16.23 → 0.17.0

package/dist/utils/keys.test.js

@@ -1,81 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { KeyManager, parseKey } from './keys.js';
-import * as fs from 'fs';
-import { isAddress } from 'viem';
-vi.mock('fs');
-describe('KeyManager', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('should generate a single key pair', () => {
-        const key = KeyManager.generateKeyPair('Test');
-        expect(key.name).toBe('Test');
-        expect(key.privateKey).toMatch(/^0x/);
-        expect(isAddress(key.address)).toBe(true);
-    });
-    it('should generate multiple key pairs', () => {
-        const keys = KeyManager.generateMultiple(3, 'Op');
-        expect(keys.length).toBe(3);
-        expect(keys[0].name).toBe('Op_1');
-        expect(keys[2].name).toBe('Op_3');
-    });
-    it('should save keys to env file', () => {
-        const keys = [
-            { name: 'Admin', privateKey: '0x1', address: '0x1' }
-        ];
-        fs.existsSync.mockReturnValue(false);
-        KeyManager.saveToEnvFile('/mock/.env', keys);
-        expect(fs.writeFileSync).toHaveBeenCalledWith('/mock/.env', expect.stringContaining('ADMIN_PRIVATE_KEY=0x1'), expect.objectContaining({ mode: 0o600 }));
-    });
-    it('should load keys from env file', () => {
-        const mockEnv = 'ADMIN_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80\n';
-        fs.existsSync.mockReturnValue(true);
-        fs.readFileSync.mockReturnValue(mockEnv);
-        const keys = KeyManager.loadFromEnvFile('/mock/.env');
-        expect(keys.length).toBe(1);
-        expect(keys[0].name).toBe('admin');
-        expect(keys[0].privateKey).toBe('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80');
-    });
-    it('should save and load keys from json file', () => {
-        const keys = [
-            { name: 'Test', privateKey: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' }
-        ];
-        fs.existsSync.mockReturnValueOnce(false).mockReturnValueOnce(true);
-        fs.readFileSync.mockReturnValue(JSON.stringify({ keys }));
-        KeyManager.saveToJsonFile('/mock/keys.json', keys);
-        expect(fs.writeFileSync).toHaveBeenCalled();
-        const loaded = KeyManager.loadFromJsonFile('/mock/keys.json');
-        expect(loaded).toEqual(keys);
-    });
-    it('should parse keys with and without prefix', () => {
-        expect(parseKey('abc')).toBe('0xabc');
-        expect(parseKey('0xabc')).toBe('0xabc');
-    });
-    it('should throw if json file exists and overwrite is false', () => {
-        fs.existsSync.mockReturnValue(true);
-        expect(() => KeyManager.saveToJsonFile('/mock/keys.json', [], false)).toThrow(/File already exists/);
-    });
-    it('should throw if json file not found', () => {
-        fs.existsSync.mockReturnValue(false);
-        expect(() => KeyManager.loadFromJsonFile('/mock/missing.json')).toThrow(/File not found/);
-    });
-    it('should print keys with masked private key', () => {
-        const consoleSpy = vi.spyOn(console, 'log');
-        const keys = [
-            { name: 'Admin', privateKey: '0x1234567890123456789012345678901234567890', address: '0xAddress' }
-        ];
-        KeyManager.printKeys(keys, false);
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Generated Keys'));
-        // Check for masked key format (start...end)
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringMatching(/Private Key: 0x12345678\.\.\.34567890/));
-        expect(consoleSpy).not.toHaveBeenCalledWith(expect.stringContaining('0x1234567890123456789012345678901234567890'));
-    });
-    it('should print keys with full private key', () => {
-        const consoleSpy = vi.spyOn(console, 'log');
-        const keys = [
-            { name: 'Admin', privateKey: '0x1234567890123456789012345678901234567890', address: '0xAddress' }
-        ];
-        KeyManager.printKeys(keys, true);
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('0x1234567890123456789012345678901234567890'));
-    });
-});

package/dist/utils/roleData.test.d.ts

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

package/dist/utils/roleData.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { RoleDataFactory, RoleIds } from './roleData.js';
-import { zeroAddress } from 'viem';
-describe('RoleDataFactory', () => {
-    it('should have correct role ids', () => {
-        expect(RoleIds.COMMUNITY).toBeDefined();
-        expect(RoleIds.ENDUSER).toBeDefined();
-    });
-    it('should encode and decode community data', () => {
-        const params = {
-            name: 'MyCommunity',
-            ensName: 'my.eth',
-            website: 'https://my.com',
-            description: 'desc',
-            logoURI: 'logo',
-            stakeAmount: 100n
-        };
-        const encoded = RoleDataFactory.community(params);
-        const decoded = RoleDataFactory.decodeCommunity(encoded);
-        expect(decoded.name).toBe(params.name);
-        expect(decoded.stakeAmount).toBe(params.stakeAmount);
-    });
-    it('should encode and decode community data with different params', () => {
-        const params = {
-            name: 'VibeCommunity',
-            ensName: 'vibe.eth',
-            website: 'https://vibe.io',
-            description: 'Good vibes only',
-            logoURI: 'ipfs://logo',
-            stakeAmount: 100n
-        };
-        const encoded = RoleDataFactory.community(params);
-        const decoded = RoleDataFactory.decodeCommunity(encoded);
-        expect(decoded.name).toBe(params.name);
-        expect(decoded.ensName).toBe(params.ensName);
-        expect(decoded.stakeAmount).toBe(params.stakeAmount);
-    });
-    it('should encode community with default values', () => {
-        const encoded = RoleDataFactory.community();
-        const decoded = RoleDataFactory.decodeCommunity(encoded);
-        expect(decoded.name).toBe('TestCommunity');
-        expect(decoded.stakeAmount).toBe(0n);
-    });
-    it('should use default values for community', () => {
-        const encoded = RoleDataFactory.community();
-        const decoded = RoleDataFactory.decodeCommunity(encoded);
-        expect(decoded.name).toBe('TestCommunity');
-        expect(decoded.stakeAmount).toBe(0n);
-    });
-    it('should encode and decode endUser data', () => {
-        const params = {
-            account: '0x1111111111111111111111111111111111111111',
-            community: '0x2222222222222222222222222222222222222222',
-            avatarURI: 'avatar',
-            ensName: 'user.eth',
-            stakeAmount: 50n
-        };
-        const encoded = RoleDataFactory.endUser(params);
-        const decoded = RoleDataFactory.decodeEndUser(encoded);
-        expect(decoded.account).toBe(params.account);
-        expect(decoded.community).toBe(params.community);
-        expect(decoded.stakeAmount).toBe(params.stakeAmount);
-    });
-    it('should encode endUser with default values', () => {
-        const encoded = RoleDataFactory.endUser();
-        const decoded = RoleDataFactory.decodeEndUser(encoded);
-        expect(decoded.account).toBe(zeroAddress);
-        expect(decoded.stakeAmount).toBe(0n);
-    });
-    it('should handle paymasterSuper and dvt (empty data)', () => {
-        expect(RoleDataFactory.paymasterSuper()).toBe('0x');
-        expect(RoleDataFactory.dvt()).toBe('0x');
-    });
-});

package/dist/utils/testScenarios.test.d.ts

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

package/dist/utils/testScenarios.test.js

@@ -1,68 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { UserOpScenarioBuilder, UserOpScenarioType } from './testScenarios.js';
-describe('UserOpScenarioBuilder', () => {
-    it('should build NATIVE transfer scenario', async () => {
-        const mockPublicClient = {
-            readContract: vi.fn().mockResolvedValue(0n),
-            chain: { id: 1 }
-        };
-        const params = {
-            sender: '0x0000000000000000000000000000000000000001',
-            ownerAccount: { signMessage: vi.fn().mockResolvedValue('0xsig') },
-            recipient: '0x0000000000000000000000000000000000000002',
-            tokenAddress: '0x0000000000000000000000000000000000000003',
-            amount: 100n,
-            entryPoint: '0x0000000000000000000000000000000000000004',
-            chainId: 1,
-            publicClient: mockPublicClient
-        };
-        const result = await UserOpScenarioBuilder.buildTransferScenario(UserOpScenarioType.NATIVE, params);
-        expect(result.userOp.paymasterAndData).toBe('0x');
-        expect(result.userOp.signature).toBe('0xsig');
-    });
-    it('should build GASLESS_V4 transfer scenario', async () => {
-        const mockPublicClient = {
-            readContract: vi.fn().mockResolvedValue(0n),
-            chain: { id: 1 }
-        };
-        const params = {
-            sender: '0x0000000000000000000000000000000000000001',
-            ownerAccount: { signMessage: vi.fn().mockResolvedValue('0xsig') },
-            recipient: '0x0000000000000000000000000000000000000002',
-            tokenAddress: '0x0000000000000000000000000000000000000003',
-            amount: 100n,
-            entryPoint: '0x0000000000000000000000000000000000000004',
-            chainId: 1,
-            publicClient: mockPublicClient,
-            paymaster: '0x0000000000000000000000000000000000000005'
-        };
-        const result = await UserOpScenarioBuilder.buildTransferScenario(UserOpScenarioType.GASLESS_V4, params);
-        expect(result.userOp.paymasterAndData).toBeDefined();
-        expect(result.userOp.paymasterAndData).not.toBe('0x');
-    });
-    it('should throw if paymaster missing for v4', async () => {
-        const params = { publicClient: { readContract: vi.fn() }, sender: '0x0000000000000000000000000000000000000001' };
-        await expect(UserOpScenarioBuilder.buildTransferScenario(UserOpScenarioType.GASLESS_V4, params))
-            .rejects.toThrow();
-    });
-    it('should build SUPER_BPNT scenario', async () => {
-        const mockPublicClient = {
-            readContract: vi.fn().mockResolvedValue(0n),
-            chain: { id: 1 }
-        };
-        const params = {
-            sender: '0x0000000000000000000000000000000000000001',
-            ownerAccount: { signMessage: vi.fn().mockResolvedValue('0xsig') },
-            recipient: '0x0000000000000000000000000000000000000002',
-            tokenAddress: '0x0000000000000000000000000000000000000003',
-            amount: 100n,
-            entryPoint: '0x0000000000000000000000000000000000000004',
-            chainId: 1,
-            publicClient: mockPublicClient,
-            paymaster: '0x0000000000000000000000000000000000000005',
-            operator: '0x0000000000000000000000000000000000000006'
-        };
-        const result = await UserOpScenarioBuilder.buildTransferScenario(UserOpScenarioType.SUPER_BPNT, params);
-        expect(result.userOp.paymasterAndData).toContain('0x');
-    });
-});

package/dist/utils/userOp.test.d.ts

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

package/dist/utils/userOp.test.js

@@ -1,152 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { UserOperationBuilder } from './userOp.js';
-import { concat } from 'viem';
-describe('UserOperationBuilder', () => {
-    const MOCK_ADDR = '0x1111111111111111111111111111111111111111';
-    const MOCK_PM = '0x2222222222222222222222222222222222222222';
-    const MOCK_TOKEN = '0x3333333333333333333333333333333333333333';
-    describe('Gas Packing', () => {
-        it('should pack account gas limits', () => {
-            const packed = UserOperationBuilder.packAccountGasLimits(100000n, 200000n);
-            expect(packed).toBeDefined();
-            expect(packed.length).toBeGreaterThan(2);
-        });
-        it('should pack gas fees', () => {
-            const packed = UserOperationBuilder.packGasFees(1000000000n, 2000000000n);
-            expect(packed).toBeDefined();
-            expect(packed.length).toBeGreaterThan(2);
-        });
-        it('should pack paymaster and data', () => {
-            const packed = UserOperationBuilder.packPaymasterAndData(MOCK_PM, 250000n, 50000n, '0x1234');
-            expect(packed).toBeDefined();
-            expect(packed.startsWith(MOCK_PM.toLowerCase())).toBe(true);
-        });
-        it('should pack PaymasterV4 deposit data', () => {
-            const validUntil = BigInt(Math.floor(Date.now() / 1000) + 3600);
-            const validAfter = BigInt(Math.floor(Date.now() / 1000));
-            const packed = UserOperationBuilder.packPaymasterV4DepositData(MOCK_PM, 250000n, 50000n, MOCK_TOKEN, validUntil, validAfter);
-            expect(packed).toBeDefined();
-            expect(packed.length).toBeGreaterThan(100);
-        });
-    });
-    describe('UserOp Formatting', () => {
-        it('should jsonify UserOp', () => {
-            const userOp = {
-                sender: MOCK_ADDR,
-                nonce: 0n,
-                initCode: '0x',
-                callData: '0x',
-                accountGasLimits: UserOperationBuilder.packAccountGasLimits(100000n, 200000n),
-                preVerificationGas: 50000n,
-                gasFees: UserOperationBuilder.packGasFees(1000000000n, 2000000000n),
-                paymasterAndData: '0x',
-                signature: '0x'
-            };
-            const jsonified = UserOperationBuilder.jsonifyUserOp(userOp);
-            expect(jsonified).toBeDefined();
-            expect(jsonified.sender).toBe(MOCK_ADDR);
-        });
-        it('should convert to Alchemy format', () => {
-            const userOp = {
-                sender: MOCK_ADDR,
-                nonce: '0x0',
-                initCode: '0x',
-                callData: '0x',
-                accountGasLimits: UserOperationBuilder.packAccountGasLimits(100000n, 200000n),
-                preVerificationGas: '0xc350',
-                gasFees: UserOperationBuilder.packGasFees(1000000000n, 2000000000n),
-                paymasterAndData: '0x', // no paymaster
-                signature: '0x'
-            };
-            const alchemy = UserOperationBuilder.toAlchemyUserOperation(userOp);
-            expect(alchemy).toBeDefined();
-            expect(alchemy.sender).toBe(MOCK_ADDR);
-            expect(alchemy.verificationGasLimit).toBeDefined();
-            expect(alchemy.callGasLimit).toBeDefined();
-        });
-        it('should unpack paymaster and data (full v0.7 format)', () => {
-            const pmData = UserOperationBuilder.packPaymasterAndData(MOCK_PM, 300000n, 100000n, '0x12345678');
-            const userOp = {
-                sender: MOCK_ADDR,
-                nonce: '0x0',
-                initCode: '0x',
-                callData: '0x',
-                accountGasLimits: '0x',
-                preVerificationGas: '0x0',
-                gasFees: '0x',
-                paymasterAndData: pmData,
-                signature: '0x'
-            };
-            const alchemy = UserOperationBuilder.toAlchemyUserOperation(userOp);
-            expect(alchemy.paymaster).toBe(MOCK_PM);
-            expect(alchemy.paymasterVerificationGasLimit).toBeDefined();
-            expect(alchemy.paymasterPostOpGasLimit).toBeDefined();
-            expect(alchemy.paymasterData).toBe('0x12345678');
-        });
-        it('should unpack paymaster and data (legacy format fallback)', () => {
-            // Not enough bytes for Gas Limits, treated as paymaster + data
-            const legacyPmData = concat([MOCK_PM, '0xabcdef']);
-            const userOp = {
-                sender: MOCK_ADDR,
-                nonce: '0x0',
-                initCode: '0x',
-                callData: '0x',
-                accountGasLimits: '0x',
-                preVerificationGas: '0x0',
-                gasFees: '0x',
-                paymasterAndData: legacyPmData,
-                signature: '0x'
-            };
-            const alchemy = UserOperationBuilder.toAlchemyUserOperation(userOp);
-            expect(alchemy.paymaster).toBe(MOCK_PM);
-            expect(alchemy.paymasterData).toBe('0xabcdef');
-            expect(alchemy.paymasterVerificationGasLimit).toBeDefined(); // defaults
-        });
-        it('should unpack initCode into factory and factoryData', () => {
-            const factory = MOCK_ADDR;
-            const factoryData = '0xdeadbeef';
-            const initCode = concat([factory, factoryData]);
-            const userOp = {
-                sender: MOCK_ADDR,
-                nonce: '0x0',
-                initCode: initCode,
-                callData: '0x',
-                accountGasLimits: '0x',
-                preVerificationGas: '0x0',
-                gasFees: '0x',
-                paymasterAndData: '0x',
-                signature: '0x'
-            };
-            const alchemy = UserOperationBuilder.toAlchemyUserOperation(userOp);
-            expect(alchemy.factory.toLowerCase()).toBe(factory.toLowerCase());
-            expect(alchemy.factoryData).toBe(factoryData);
-        });
-        it('should jsonify various types', () => {
-            const userOp = {
-                sender: MOCK_ADDR,
-                nonce: 123, // number
-                initCode: '0x',
-                callData: '0x',
-                accountGasLimits: '0x',
-                preVerificationGas: '0x10', // string
-                gasFees: '0x',
-                paymasterAndData: '0x',
-                signature: '0x'
-            };
-            const json = UserOperationBuilder.jsonifyUserOp(userOp);
-            expect(json.nonce).toBe('0x7b');
-            expect(json.preVerificationGas).toBe('0x10');
-        });
-        it('should handle leading zeros in string quantities for Alchemy', () => {
-            const userOp = {
-                sender: MOCK_ADDR,
-                nonce: '0x0001', // leading zeros
-                preVerificationGas: '0x0', // valid zero
-                // ... others
-            };
-            const json = UserOperationBuilder.jsonifyUserOp(userOp);
-            expect(json.nonce).toBe('0x1'); // compact
-            expect(json.preVerificationGas).toBe('0x0');
-        });
-    });
-});