@aastar/sdk 0.16.22 → 0.17.0

package/dist/errors/AAStarError.d.ts

@@ -1,26 +0,0 @@
-export declare enum AAStarErrorCode {
-    VALIDATION_ERROR = "VALIDATION_ERROR",
-    CONTRACT_ERROR = "CONTRACT_ERROR",
-    NETWORK_ERROR = "NETWORK_ERROR",
-    CONFIGURATION_ERROR = "CONFIGURATION_ERROR",
-    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
-    PERMISSION_DENIED = "PERMISSION_DENIED",
-    OPERATION_FAILED = "OPERATION_FAILED",
-    UNKNOWN_ERROR = "UNKNOWN_ERROR"
-}
-export declare class AAStarError extends Error {
-    readonly code: AAStarErrorCode;
-    readonly details?: any;
-    constructor(message: string, code?: AAStarErrorCode, details?: any);
-}
-/**
- * Error factory functions for consistent error creation
- */
-export declare const createError: {
-    validation: (field: string, reason: string) => AAStarError;
-    contract: (contract: string, reason: string) => AAStarError;
-    network: (operation: string, reason: string) => AAStarError;
-    insufficientFunds: (required: string, available: string) => AAStarError;
-    permissionDenied: (operation: string, reason: string) => AAStarError;
-    operationFailed: (operation: string, reason: string) => AAStarError;
-};

package/dist/errors/AAStarError.js

@@ -1,32 +0,0 @@
-export var AAStarErrorCode;
-(function (AAStarErrorCode) {
-    AAStarErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-    AAStarErrorCode["CONTRACT_ERROR"] = "CONTRACT_ERROR";
-    AAStarErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
-    AAStarErrorCode["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
-    AAStarErrorCode["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-    AAStarErrorCode["PERMISSION_DENIED"] = "PERMISSION_DENIED";
-    AAStarErrorCode["OPERATION_FAILED"] = "OPERATION_FAILED";
-    AAStarErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(AAStarErrorCode || (AAStarErrorCode = {}));
-export class AAStarError extends Error {
-    code;
-    details;
-    constructor(message, code = AAStarErrorCode.UNKNOWN_ERROR, details) {
-        super(message);
-        this.name = 'AAStarError';
-        this.code = code;
-        this.details = details;
-    }
-}
-/**
- * Error factory functions for consistent error creation
- */
-export const createError = {
-    validation: (field, reason) => new AAStarError(`Validation failed for ${field}: ${reason}`, AAStarErrorCode.VALIDATION_ERROR, { field, reason }),
-    contract: (contract, reason) => new AAStarError(`Contract ${contract} error: ${reason}`, AAStarErrorCode.CONTRACT_ERROR, { contract, reason }),
-    network: (operation, reason) => new AAStarError(`Network error during ${operation}: ${reason}`, AAStarErrorCode.NETWORK_ERROR, { operation, reason }),
-    insufficientFunds: (required, available) => new AAStarError(`Insufficient funds: required ${required}, available ${available}`, AAStarErrorCode.INSUFFICIENT_FUNDS, { required, available }),
-    permissionDenied: (operation, reason) => new AAStarError(`Permission denied for ${operation}: ${reason}`, AAStarErrorCode.PERMISSION_DENIED, { operation, reason }),
-    operationFailed: (operation, reason) => new AAStarError(`Operation ${operation} failed: ${reason}`, AAStarErrorCode.OPERATION_FAILED, { operation, reason }),
-};

package/dist/errors/AAStarError.test.d.ts

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

package/dist/errors/AAStarError.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { AAStarError, AAStarErrorCode } from './AAStarError.js';
-describe('AAStarError', () => {
-    describe('Error Creation', () => {
-        it('should create VALIDATION_ERROR', () => {
-            const error = new AAStarError('Invalid address format', AAStarErrorCode.VALIDATION_ERROR);
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(AAStarError);
-            expect(error.code).toBe(AAStarErrorCode.VALIDATION_ERROR);
-            expect(error.message).toContain('Invalid address format');
-            expect(error.name).toBe('AAStarError');
-        });
-        it('should create CONTRACT_ERROR', () => {
-            const error = new AAStarError('Execution reverted', AAStarErrorCode.CONTRACT_ERROR);
-            expect(error.code).toBe(AAStarErrorCode.CONTRACT_ERROR);
-            expect(error.message).toContain('Execution reverted');
-        });
-        it('should create NETWORK_ERROR', () => {
-            const error = new AAStarError('Network timeout', AAStarErrorCode.NETWORK_ERROR);
-            expect(error.code).toBe(AAStarErrorCode.NETWORK_ERROR);
-            expect(error.message).toContain('Network timeout');
-        });
-        it('should create CONFIGURATION_ERROR', () => {
-            const error = new AAStarError('Missing RPC URL', AAStarErrorCode.CONFIGURATION_ERROR);
-            expect(error.code).toBe(AAStarErrorCode.CONFIGURATION_ERROR);
-            expect(error.message).toContain('Missing RPC URL');
-        });
-        it('should create UNKNOWN_ERROR', () => {
-            const error = new AAStarError('Unexpected error');
-            expect(error.code).toBe(AAStarErrorCode.UNKNOWN_ERROR);
-        });
-    });
-    describe('Error Properties', () => {
-        it('should have correct error name', () => {
-            const error = new AAStarError('Test error', AAStarErrorCode.VALIDATION_ERROR);
-            expect(error.name).toBe('AAStarError');
-        });
-        it('should maintain stack trace', () => {
-            const error = new AAStarError('Test error', AAStarErrorCode.CONTRACT_ERROR);
-            expect(error.stack).toBeDefined();
-            expect(error.stack).toContain('AAStarError');
-        });
-        it('should preserve original message', () => {
-            const originalMessage = 'Detailed error description';
-            const error = new AAStarError(originalMessage, AAStarErrorCode.NETWORK_ERROR);
-            expect(error.message).toBe(originalMessage);
-        });
-    });
-    describe('Error Codes Enumeration', () => {
-        it('should have all expected error codes', () => {
-            expect(AAStarErrorCode.VALIDATION_ERROR).toBe('VALIDATION_ERROR');
-            expect(AAStarErrorCode.CONTRACT_ERROR).toBe('CONTRACT_ERROR');
-            expect(AAStarErrorCode.NETWORK_ERROR).toBe('NETWORK_ERROR');
-            expect(AAStarErrorCode.CONFIGURATION_ERROR).toBe('CONFIGURATION_ERROR');
-            expect(AAStarErrorCode.UNKNOWN_ERROR).toBe('UNKNOWN_ERROR');
-        });
-    });
-    describe('instanceof checks', () => {
-        it('should be instance of Error', () => {
-            const error = new AAStarError('Test', AAStarErrorCode.VALIDATION_ERROR);
-            expect(error instanceof Error).toBe(true);
-        });
-        it('should be instance of AAStarError', () => {
-            const error = new AAStarError('Test', AAStarErrorCode.CONTRACT_ERROR);
-            expect(error instanceof AAStarError).toBe(true);
-        });
-        it('should differentiate from standard Error', () => {
-            const aastarError = new AAStarError('Test', AAStarErrorCode.VALIDATION_ERROR);
-            const standardError = new Error('Test');
-            expect(aastarError instanceof AAStarError).toBe(true);
-            expect(standardError instanceof AAStarError).toBe(false);
-        });
-    });
-});

package/dist/errors/decoder.test.d.ts

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

package/dist/errors/decoder.test.js

@@ -1,90 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { decodeContractError } from './decoder.js';
-import * as viem from 'viem';
-vi.mock('viem', async () => {
-    const actual = await vi.importActual('viem');
-    return {
-        ...actual,
-        decodeErrorResult: vi.fn()
-    };
-});
-describe('ErrorDecoder', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    it('should extract data from viem error walk', () => {
-        const mockError = {
-            walk: (fn) => {
-                const e = { data: '0x123' };
-                return fn(e) ? e : null;
-            }
-        };
-        viem.decodeErrorResult.mockReturnValue({
-            errorName: 'Unauthorized',
-            args: []
-        });
-        const result = decodeContractError(mockError);
-        expect(result).toContain('Unauthorized');
-    });
-    it('should extract data from cause', () => {
-        const mockError = {
-            cause: { data: '0x123' }
-        };
-        viem.decodeErrorResult.mockReturnValue({
-            errorName: 'InsufficientBalance',
-            args: [100n, 500n]
-        });
-        const result = decodeContractError(mockError);
-        expect(result).toContain('InsufficientBalance');
-        expect(result).toContain('Available 100, Required 500');
-    });
-    it('should handle specialized formatting for RoleNotConfigured', () => {
-        viem.decodeErrorResult.mockReturnValue({
-            errorName: 'RoleNotConfigured',
-            args: ['0x1', false]
-        });
-        const result = decodeContractError({ data: '0x123' });
-        expect(result).toContain('Role 0x1 is INACTIVE');
-    });
-    it('should fallback to unknown error message if decoding fails', () => {
-        viem.decodeErrorResult.mockImplementation(() => { throw new Error('mismatch'); });
-        const result = decodeContractError({ data: '0x1234567890' });
-        expect(result).toContain('Unknown Error (data: 0x12345678...)');
-    });
-    it('should handle raw revert messages', () => {
-        const result = decodeContractError({ message: 'execution reverted: CustomError' });
-        expect(result).toBe('execution reverted: CustomError');
-    });
-    it('should return null for non-error input', () => {
-        expect(decodeContractError(null)).toBeNull();
-    });
-    it('should extract data from nested object structure', () => {
-        // Case A: { data: { data: "0x..." } }
-        const errorA = { data: { data: '0xA1' } };
-        viem.decodeErrorResult.mockReturnValue({ errorName: 'TestA', args: [] });
-        expect(decodeContractError(errorA)).toContain('TestA');
-        // Case B: { data: { object: "0x..." } }
-        const errorB = { data: { object: '0xB1' } };
-        viem.decodeErrorResult.mockReturnValue({ errorName: 'TestB', args: [] });
-        expect(decodeContractError(errorB)).toContain('TestB');
-    });
-    it('should format all known error types', () => {
-        const testCases = [
-            { name: 'RoleAlreadyGranted', args: ['0xRole', '0xUser'], expected: 'User 0xUser already has role 0xRole' },
-            { name: 'InsufficientStake', args: [100n, 200n], expected: 'Provided 100, Required 200' },
-            { name: 'InvalidParameter', args: ['BadInput'], expected: 'InvalidParameter: BadInput' },
-            { name: 'RoleNotGranted', args: ['0xRole', '0xUser'], expected: 'User 0xUser does not have role 0xRole' },
-            { name: 'UnknownCustom', args: [123n], expected: 'UnknownCustom: ["123"]' }
-        ];
-        for (const { name, args, expected } of testCases) {
-            viem.decodeErrorResult.mockReturnValue({ errorName: name, args });
-            const result = decodeContractError({ data: '0x1' });
-            expect(result).toContain(expected);
-        }
-    });
-    it('should handle non-string unknown data', () => {
-        viem.decodeErrorResult.mockImplementation(() => { throw new Error('fail'); });
-        const result = decodeContractError({ data: { complex: true } });
-        expect(result).toContain('non-string data');
-    });
-});

package/dist/node/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Node.js specific utilities
- * ⚠️ NOT COMPATIBLE WITH BROWSER ENVIRONMENTS
- */
-export { KeyManager, type KeyPair } from '../utils/keys.js';
-export { FundingManager, type FundingParams } from '../utils/funding.js';
-export * from '../utils/testScenarios.js';

package/dist/node/index.js

@@ -1,7 +0,0 @@
-/**
- * Node.js specific utilities
- * ⚠️ NOT COMPATIBLE WITH BROWSER ENVIRONMENTS
- */
-export { KeyManager } from '../utils/keys.js';
-export { FundingManager } from '../utils/funding.js';
-export * from '../utils/testScenarios.js';

package/dist/types/result.d.ts

@@ -1,15 +0,0 @@
-import { AAStarError } from '../errors/AAStarError.js';
-export type SDKResult<T> = {
-    success: true;
-    data: T;
-} | {
-    success: false;
-    error: AAStarError;
-};
-export declare function success<T>(data: T): SDKResult<T>;
-export declare function failure<T>(error: AAStarError): SDKResult<T>;
-/**
- * Utility to wrap a Promise in an SDKResult.
- * Handles AAStarError explicitly, and wraps unknown errors.
- */
-export declare function safeSDKCall<T>(promise: Promise<T>): Promise<SDKResult<T>>;

package/dist/types/result.js

@@ -1,23 +0,0 @@
-import { AAStarError } from '../errors/AAStarError.js';
-export function success(data) {
-    return { success: true, data };
-}
-export function failure(error) {
-    return { success: false, error };
-}
-/**
- * Utility to wrap a Promise in an SDKResult.
- * Handles AAStarError explicitly, and wraps unknown errors.
- */
-export async function safeSDKCall(promise) {
-    try {
-        const data = await promise;
-        return success(data);
-    }
-    catch (e) {
-        if (e instanceof AAStarError) {
-            return failure(e);
-        }
-        return failure(new AAStarError(e.message || 'Unknown error occurred', undefined, e));
-    }
-}

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

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

package/dist/utils/errorHandler.test.js

@@ -1,89 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { handleContractError } from './errorHandler.js';
-describe('ErrorHandler', () => {
-    const MOCK_CTX = {
-        operation: 'test operation',
-        roleId: '0xRole',
-        account: '0xUser'
-    };
-    it('should enhance known contract errors', () => {
-        const error = new Error('Execution reverted: Error: RoleNotGranted(0xabc, 0xdef)');
-        const enhanced = handleContractError(error, MOCK_CTX);
-        expect(enhanced.message).toContain('does not have role');
-        expect(enhanced.message).toContain('Please register for this role first');
-    });
-    it('should use context if args missing', () => {
-        const error = new Error('Execution reverted: Error: RoleNotGranted()');
-        const enhanced = handleContractError(error, MOCK_CTX);
-        expect(enhanced.message).toContain('0xUser does not have role 0xRole');
-    });
-    it('should extract error from message if data.errorName is missing', () => {
-        // Simulate an error where data.errorName is missing but message contains relevant info
-        const error = {
-            message: 'Error: Registry: Role "0xRole" is not configured in the Registry'
-        };
-        const enhanced = handleContractError(error, MOCK_CTX);
-        expect(enhanced.message).toContain('is not configured in the Registry');
-    });
-    it('should handle all known contract errors', () => {
-        const errors = [
-            { name: 'RoleNotGranted', args: ['0xRole', '0xUser'], match: 'does not have role' },
-            { name: 'InsufficientBalance', args: [], match: 'Insufficient balance' },
-            { name: 'InvalidParameter', args: ['BadParam'], match: 'Invalid parameter' },
-            { name: 'Unauthorized', args: [], match: 'Unauthorized operation' },
-            { name: 'OwnableUnauthorizedAccount', args: ['0xUser'], match: 'not authorized' },
-            { name: 'RoleNotConfigured', args: ['0xRole'], match: 'not configured' }
-        ];
-        for (const { name, args, match } of errors) {
-            const error = {
-                data: { errorName: name, args },
-                message: `Error: ${name}(...`
-            };
-            const enhanced = handleContractError(error, MOCK_CTX);
-            expect(enhanced.message).toContain(match);
-        }
-    });
-    it('should fallback to stringify matching', () => {
-        // The implementation checks if JSON.stringify(error) includes known keys
-        const weirdError = {
-            inner: 'RoleNotConfigured'
-        };
-        const enhanced = handleContractError(weirdError, MOCK_CTX);
-        expect(enhanced.message).toContain('not configured');
-    });
-    it('should fallback for unknown error', () => {
-        const error = new Error('Random connection failed');
-        const enhanced = handleContractError(error, MOCK_CTX);
-        expect(enhanced.message).toContain('Random connection failed');
-    });
-    it('should handle empty error object', () => {
-        const enhanced = handleContractError({}, MOCK_CTX);
-        expect(enhanced.message).toBe('Failed to test operation: Unknown error');
-    });
-    it('should prioritize args over context for RoleAlreadyGranted', () => {
-        const enhanced = handleContractError({
-            data: { errorName: 'RoleAlreadyGranted', args: ['0xArgRole', '0xArgUser'] }
-        }, MOCK_CTX);
-        expect(enhanced.message).toContain('Account 0xArgUser already has this role (0xArgRole)');
-    });
-    it('should use context if args missing for RoleAlreadyGranted', () => {
-        const enhanced = handleContractError({
-            data: { errorName: 'RoleAlreadyGranted', args: [] }
-        }, MOCK_CTX);
-        expect(enhanced.message).toContain(`Account ${MOCK_CTX.account} already has this role (${MOCK_CTX.roleId})`);
-    });
-    it('should prioritize args for InsufficientStake', () => {
-        const enhanced = handleContractError({
-            data: { errorName: 'InsufficientStake', args: [100n, 200n] }
-        }, MOCK_CTX);
-        expect(enhanced.message).toContain('Required: 100');
-        expect(enhanced.message).toContain('Actual: 200');
-    });
-    it('should handle missing args for InsufficientStake', () => {
-        const enhanced = handleContractError({
-            data: { errorName: 'InsufficientStake', args: [] } // Missing args
-        }, MOCK_CTX);
-        expect(enhanced.message).toContain('Insufficient stake for this operation.');
-        expect(enhanced.message).not.toContain('Required:');
-    });
-});

package/dist/utils/eventDecoder.d.ts

@@ -1,7 +0,0 @@
-export interface DecodedEvent {
-    contractName: string;
-    eventName: string;
-    args: any;
-}
-export declare function decodeContractEvents(logs: any[]): DecodedEvent[];
-export declare function logDecodedEvents(events: DecodedEvent[]): void;

package/dist/utils/eventDecoder.js

@@ -1,54 +0,0 @@
-import { decodeEventLog } from 'viem';
-import { RegistryABI, SuperPaymasterABI, GTokenStakingABI, MySBTABI, xPNTsTokenABI, PaymasterFactoryABI } from '../index.js';
-const ABIS_TO_TRY = [
-    { name: 'Registry', abi: RegistryABI },
-    { name: 'SuperPaymaster', abi: SuperPaymasterABI },
-    { name: 'GTokenStaking', abi: GTokenStakingABI },
-    { name: 'MySBT', abi: MySBTABI },
-    { name: 'xPNTsToken', abi: xPNTsTokenABI },
-    { name: 'PaymasterFactory', abi: PaymasterFactoryABI }
-];
-export function decodeContractEvents(logs) {
-    const decodedEvents = [];
-    for (const log of logs) {
-        if (typeof log.data !== 'string' || !log.data.startsWith('0x')) {
-            console.warn('   ⚠️ Skipping log with invalid data:', log);
-            continue;
-        }
-        for (const { name, abi } of ABIS_TO_TRY) {
-            try {
-                const decoded = decodeEventLog({
-                    abi: abi,
-                    data: log.data,
-                    topics: log.topics
-                });
-                if (decoded && decoded.eventName) {
-                    decodedEvents.push({
-                        contractName: name,
-                        eventName: decoded.eventName,
-                        args: decoded.args
-                    });
-                    break; // Found the right ABI for this log
-                }
-            }
-            catch (e) {
-                // Ignore mismatch errors, but log weird ones
-                if (e.message && Object.values(e.message).some((m) => m?.includes?.('slice'))) {
-                    console.warn(`   ⚠️ decodeEventLog failed (slice error) for ${name}:`, e.message);
-                }
-            }
-        }
-    }
-    return decodedEvents;
-}
-export function logDecodedEvents(events) {
-    for (const event of events) {
-        console.log(`📡 [${event.contractName}] Event: ${event.eventName}`);
-        if (event.args) {
-            Object.entries(event.args).forEach(([key, value]) => {
-                const displayValue = typeof value === 'bigint' ? value.toString() : value;
-                console.log(`   └─ ${key}: ${displayValue}`);
-            });
-        }
-    }
-}

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

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

package/dist/utils/eventDecoder.test.js

@@ -1,48 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { decodeContractEvents, logDecodedEvents } from './eventDecoder.js';
-import { keccak256, encodeAbiParameters, stringToBytes } from 'viem';
-describe('eventDecoder', () => {
-    it('should decode known events', () => {
-        // Manual topic construction for RoleGranted(bytes32,address,address)
-        const ROLE_GRANTED_SIG = keccak256(stringToBytes('RoleGranted(bytes32,address,address)'));
-        const roleId = keccak256(stringToBytes('COMMUNITY'));
-        const account = '0x0000000000000000000000000000000000000001';
-        const sender = '0x0000000000000000000000000000000000000002';
-        const topics = [
-            ROLE_GRANTED_SIG,
-            roleId,
-            encodeAbiParameters([{ type: 'address' }], [account]),
-            encodeAbiParameters([{ type: 'address' }], [sender])
-        ];
-        const logs = [{
-                data: '0x',
-                topics: topics
-            }];
-        const decoded = decodeContractEvents(logs);
-        expect(decoded).toHaveLength(1);
-        expect(decoded[0].contractName).toBe('Registry');
-        expect(decoded[0].eventName).toBe('RoleGranted');
-    });
-    it('should skip invalid logs', () => {
-        const logs = [{ data: 'invalid', topics: [] }];
-        const decoded = decodeContractEvents(logs);
-        expect(decoded).toHaveLength(0);
-    });
-    it('should handle decoding errors gracefully', () => {
-        const logs = [{ data: '0x123', topics: ['0x0000000000000000000000000000000000000000000000000000000000000000'] }];
-        const decoded = decodeContractEvents(logs);
-        expect(decoded).toHaveLength(0);
-    });
-    it('should log decoded events', () => {
-        const consoleSpy = vi.spyOn(console, 'log');
-        const events = [{
-                contractName: 'Test',
-                eventName: 'Event',
-                args: { amount: 100n, user: '0x0000000000000000000000000000000000000001' }
-            }];
-        logDecodedEvents(events);
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[Test] Event: Event'));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('amount: 100'));
-        consoleSpy.mockRestore();
-    });
-});

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

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

package/dist/utils/funding.test.js

@@ -1,105 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { FundingManager } from './funding.js';
-import { parseEther } from 'viem';
-vi.mock('viem', async () => {
-    const actual = await vi.importActual('viem');
-    return {
-        ...actual,
-        createPublicClient: vi.fn(() => ({
-            getBalance: vi.fn().mockResolvedValue(parseEther('1')),
-            readContract: vi.fn().mockResolvedValue(parseEther('100')),
-            simulateContract: vi.fn().mockResolvedValue({ request: {} }),
-            waitForTransactionReceipt: vi.fn().mockResolvedValue({ status: 'success' })
-        })),
-        createWalletClient: vi.fn(() => ({
-            sendTransaction: vi.fn().mockResolvedValue('0xhash'),
-            writeContract: vi.fn().mockResolvedValue('0xhash'),
-            account: { address: '0xsupplier' }
-        })),
-        http: vi.fn()
-    };
-});
-describe('FundingManager', () => {
-    const params = {
-        rpcUrl: 'http://localhost:8545',
-        chain: { id: 1 },
-        supplierKey: '0x1234567890123456789012345678901234567890123456789012345678901234',
-        targetAddress: '0x1111111111111111111111111111111111111111'
-    };
-    it('should fund with ETH', async () => {
-        const result = await FundingManager.fundWithETH({ ...params, amount: '0.1' });
-        expect(result.success).toBe(true);
-        expect(result.txHash).toBe('0xhash');
-    });
-    it('should fund with Token', async () => {
-        const result = await FundingManager.fundWithToken({
-            ...params,
-            tokenAddress: '0x2222222222222222222222222222222222222222',
-            amount: '100'
-        });
-        expect(result.success).toBe(true);
-    });
-    it('should ensure funding when below threshold', async () => {
-        const results = await FundingManager.ensureFunding({
-            ...params,
-            minETH: '2.0',
-            targetETH: '1.0'
-        });
-        expect(results[0].txHash).toBe('0xhash');
-    });
-    it('should batch fund ETH', async () => {
-        const results = await FundingManager.batchFundETH(params, [
-            { address: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', amount: '0.1' },
-            { address: '0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB', amount: '0.2' }
-        ]);
-        expect(results).toHaveLength(2);
-        expect(results[0].success).toBe(true);
-    });
-    it('should get ETH balance', async () => {
-        const balance = await FundingManager.getETHBalance(params);
-        expect(balance).toBe(parseEther('1'));
-    });
-    it('should get Token balance', async () => {
-        const balance = await FundingManager.getTokenBalance(params, '0x2222222222222222222222222222222222222222');
-        expect(balance).toBe(parseEther('100'));
-    });
-    it('should batch fund Token', async () => {
-        const results = await FundingManager.batchFundToken(params, '0x2222222222222222222222222222222222222222', [
-            { address: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', amount: '100' },
-            { address: '0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB', amount: '200' }
-        ]);
-        expect(results).toHaveLength(2);
-    });
-    it('should handle ensure funding with token', async () => {
-        const results = await FundingManager.ensureFunding({
-            ...params,
-            minETH: '0.5',
-            targetETH: '1.0',
-            token: {
-                address: '0x2222222222222222222222222222222222222222',
-                minBalance: '50',
-                targetAmount: '100'
-            }
-        });
-        expect(results.length).toBeGreaterThan(0);
-    });
-    it('should handle ETH funding errors', async () => {
-        vi.spyOn(FundingManager, 'createClients').mockReturnValueOnce({
-            publicClient: {},
-            walletClient: { sendTransaction: vi.fn().mockRejectedValue(new Error('Network error')) },
-            account: {}
-        });
-        const result = await FundingManager.fundWithETH({ ...params, amount: '0.1' });
-        expect(result.success).toBe(false);
-        expect(result.error).toContain('Network error');
-    });
-    it('should handle Token funding errors', async () => {
-        vi.spyOn(FundingManager, 'createClients').mockReturnValueOnce({
-            publicClient: { simulateContract: vi.fn().mockRejectedValue(new Error('Insufficient balance')) },
-            walletClient: {},
-            account: {}
-        });
-        const result = await FundingManager.fundWithToken({ ...params, tokenAddress: '0x2222222222222222222222222222222222222222', amount: '100' });
-        expect(result.success).toBe(false);
-    });
-});

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

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