@aastar/core 0.16.7

package/dist/actions/account.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { accountActions, accountFactoryActions } from './account.js';
+describe('Account Actions', () => {
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_ACCOUNT_ADDR = '0x1111111111111111111111111111111111111111';
+    const MOCK_DEST = '0x2222222222222222222222222222222222222222';
+    const MOCK_FACTORY_ADDR = '0x3333333333333333333333333333333333333333';
+    const MOCK_OWNER = '0x4444444444444444444444444444444444444444';
+    beforeEach(() => {
+        mockAccount = {
+            address: MOCK_OWNER,
+            type: 'json-rpc'
+        };
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+    describe('accountActions', () => {
+        it('should execute transaction', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = accountActions(MOCK_ACCOUNT_ADDR)(mockWalletClient);
+            const result = await actions.execute({
+                dest: MOCK_DEST,
+                value: 100n,
+                func: '0x1234',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'execute',
+                args: [MOCK_DEST, 100n, '0x1234'],
+            }));
+        });
+        it('should execute batch transactions', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = accountActions(MOCK_ACCOUNT_ADDR)(mockWalletClient);
+            const result = await actions.executeBatch({
+                dest: [MOCK_DEST, MOCK_DEST],
+                value: [100n, 200n],
+                func: ['0x12', '0x34'],
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'executeBatch',
+                args: [[
+                        { target: MOCK_DEST, value: 100n, data: '0x12' },
+                        { target: MOCK_DEST, value: 200n, data: '0x34' }
+                    ]],
+            }));
+        });
+        it('should get nonce', async () => {
+            mockPublicClient.readContract.mockResolvedValue(5n);
+            const actions = accountActions(MOCK_ACCOUNT_ADDR)(mockPublicClient);
+            const result = await actions.getNonce();
+            expect(result).toBe(5n);
+        });
+        it('should get entry point address', async () => {
+            const mockEP = '0xEP';
+            mockPublicClient.readContract.mockResolvedValue(mockEP);
+            const actions = accountActions(MOCK_ACCOUNT_ADDR)(mockPublicClient);
+            const result = await actions.entryPoint();
+            expect(result).toBe(mockEP);
+        });
+        it('should add deposit', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = accountActions(MOCK_ACCOUNT_ADDR)(mockWalletClient);
+            const result = await actions.addDeposit({ account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should withdraw deposit to address', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = accountActions(MOCK_ACCOUNT_ADDR)(mockWalletClient);
+            const result = await actions.withdrawDepositTo({
+                withdrawAddress: MOCK_DEST,
+                amount: 100n,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should get owner', async () => {
+            mockPublicClient.readContract.mockResolvedValue(MOCK_OWNER);
+            const actions = accountActions(MOCK_ACCOUNT_ADDR)(mockPublicClient);
+            const result = await actions.owner();
+            expect(result).toBe(MOCK_OWNER);
+        });
+    });
+    describe('accountFactoryActions', () => {
+        it('should create account', async () => {
+            const txHash = '0xhash';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = accountFactoryActions(MOCK_FACTORY_ADDR)(mockWalletClient);
+            const result = await actions.createAccount({
+                owner: MOCK_OWNER,
+                salt: 0n,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should predict account address', async () => {
+            const mockAddr = '0xPREDICTED';
+            mockPublicClient.readContract.mockResolvedValue(mockAddr);
+            const actions = accountFactoryActions(MOCK_FACTORY_ADDR)(mockPublicClient);
+            const result = await actions.getAddress({ owner: MOCK_OWNER, salt: 0n });
+            expect(result).toBe(mockAddr);
+        });
+    });
+});

package/dist/actions/aggregator.d.ts

@@ -0,0 +1,17 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type AggregatorActions = {
+    registerBLSPublicKey: (args: {
+        address: Address;
+        publicKey: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setBLSThreshold: (args: {
+        address: Address;
+        threshold: number;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getBLSThreshold: (args: {
+        address: Address;
+    }) => Promise<bigint>;
+};
+export declare const aggregatorActions: () => (client: PublicClient | WalletClient) => AggregatorActions;

package/dist/actions/aggregator.js

@@ -0,0 +1,31 @@
+import { BLSAggregatorABI } from '../abis/index.js';
+export const aggregatorActions = () => (client) => ({
+    async registerBLSPublicKey({ address, publicKey, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'registerBLSPublicKey',
+            args: [publicKey],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setBLSThreshold({ address, threshold, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'setThreshold',
+            args: [BigInt(threshold)],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getBLSThreshold({ address }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'threshold',
+            args: []
+        });
+    }
+});

package/dist/actions/aggregator.test.d.ts

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

package/dist/actions/aggregator.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { aggregatorActions } from './aggregator.js';
+describe('Aggregator Actions', () => {
+    const mockAggregatorAddress = '0x1234567890123456789012345678901234567890';
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_PUBLIC_KEY = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+    beforeEach(() => {
+        mockAccount = {
+            address: '0x1111111111111111111111111111111111111111',
+            type: 'json-rpc'
+        };
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+    describe('BLS Operations', () => {
+        it('should register BLS public key', async () => {
+            const txHash = '0xabc...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = aggregatorActions()(mockWalletClient);
+            const result = await actions.registerBLSPublicKey({
+                address: mockAggregatorAddress,
+                publicKey: MOCK_PUBLIC_KEY,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                address: mockAggregatorAddress,
+                functionName: 'registerBLSPublicKey',
+                args: [MOCK_PUBLIC_KEY],
+            }));
+        });
+        it('should set BLS threshold', async () => {
+            const txHash = '0xdef...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = aggregatorActions()(mockWalletClient);
+            const result = await actions.setBLSThreshold({
+                address: mockAggregatorAddress,
+                threshold: 5,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'setThreshold',
+                args: [5n],
+            }));
+        });
+        it('should get BLS threshold', async () => {
+            mockPublicClient.readContract.mockResolvedValue(3n);
+            const actions = aggregatorActions()(mockPublicClient);
+            const result = await actions.getBLSThreshold({
+                address: mockAggregatorAddress
+            });
+            expect(result).toBe(3n);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+                address: mockAggregatorAddress,
+                functionName: 'threshold',
+            }));
+        });
+    });
+});

package/dist/actions/dvt.d.ts

@@ -0,0 +1,30 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type DVTActions = {
+    createSlashProposal: (args: {
+        address: Address;
+        operator: Address;
+        level: number;
+        reason: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    signSlashProposal: (args: {
+        address: Address;
+        proposalId: bigint;
+        signature: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeSlashWithProof: (args: {
+        address: Address;
+        proposalId: bigint;
+        repUsers: Address[];
+        newScores: bigint[];
+        epoch: bigint;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    isValidator: (args: {
+        address: Address;
+        user: Address;
+    }) => Promise<boolean>;
+};
+export declare const dvtActions: () => (client: PublicClient | WalletClient) => DVTActions;

package/dist/actions/dvt.js

@@ -0,0 +1,41 @@
+import { DVTValidatorABI } from '../abis/index.js';
+export const dvtActions = () => (client) => ({
+    async createSlashProposal({ address, operator, level, reason, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'createProposal',
+            args: [operator, level, reason],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async signSlashProposal({ address, proposalId, signature, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'signProposal',
+            args: [proposalId, signature],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async executeSlashWithProof({ address, proposalId, repUsers, newScores, epoch, proof, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'executeWithProof',
+            args: [proposalId, repUsers, newScores, epoch, proof],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async isValidator({ address, user }) {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'isValidator',
+            args: [user]
+        });
+    }
+});

package/dist/actions/dvt.test.d.ts

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

package/dist/actions/dvt.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { dvtActions } from './dvt.js';
+describe('DVT Actions', () => {
+    const mockDVTAddress = '0x1234567890123456789012345678901234567890';
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_USER = '0x2222222222222222222222222222222222222222';
+    const MOCK_OPERATOR = '0x3333333333333333333333333333333333333333';
+    beforeEach(() => {
+        mockAccount = {
+            address: '0x1111111111111111111111111111111111111111',
+            type: 'json-rpc'
+        };
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+    describe('Proposal Creation', () => {
+        it('should create slash proposal', async () => {
+            const txHash = '0xabc...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions()(mockWalletClient);
+            const result = await actions.createSlashProposal({
+                address: mockDVTAddress,
+                operator: MOCK_OPERATOR,
+                level: 1,
+                reason: 'Test slash',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                address: mockDVTAddress,
+                functionName: 'createProposal',
+                args: [MOCK_OPERATOR, 1, 'Test slash'],
+            }));
+        });
+    });
+    describe('Proposal Signing', () => {
+        it('should sign slash proposal', async () => {
+            const txHash = '0xdef...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions()(mockWalletClient);
+            const result = await actions.signSlashProposal({
+                address: mockDVTAddress,
+                proposalId: 1n,
+                signature: '0xsignature',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'signProposal',
+                args: [1n, '0xsignature'],
+            }));
+        });
+    });
+    describe('Proposal Execution', () => {
+        it('should execute slash with proof', async () => {
+            const txHash = '0xghi...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = dvtActions()(mockWalletClient);
+            const result = await actions.executeSlashWithProof({
+                address: mockDVTAddress,
+                proposalId: 1n,
+                repUsers: [MOCK_USER],
+                newScores: [100n],
+                epoch: 1n,
+                proof: '0xproof',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'executeWithProof',
+                args: [1n, [MOCK_USER], [100n], 1n, '0xproof'],
+            }));
+        });
+    });
+    describe('Validator Status', () => {
+        it('should check if user is validator', async () => {
+            mockPublicClient.readContract.mockResolvedValue(true);
+            const actions = dvtActions()(mockPublicClient);
+            const result = await actions.isValidator({
+                address: mockDVTAddress,
+                user: MOCK_USER
+            });
+            expect(result).toBe(true);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+                address: mockDVTAddress,
+                functionName: 'isValidator',
+                args: [MOCK_USER],
+            }));
+        });
+    });
+});

package/dist/actions/entryPoint.d.ts

@@ -0,0 +1,90 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export declare enum EntryPointVersion {
+    V06 = "0.6",
+    V07 = "0.7"
+}
+export type EntryPointActions = {
+    balanceOf: (args: {
+        account: Address;
+    }) => Promise<bigint>;
+    depositTo: (args: {
+        account: Address;
+        amount: bigint;
+        txAccount?: Account | Address;
+    }) => Promise<Hash>;
+    getNonce: (args: {
+        sender: Address;
+        key: bigint;
+    }) => Promise<bigint>;
+    getDepositInfo: (args: {
+        account: Address;
+    }) => Promise<{
+        deposit: bigint;
+        staked: boolean;
+        stake: bigint;
+        unstakeDelaySec: number;
+        withdrawTime: number;
+    }>;
+    addStake: (args: {
+        unstakeDelaySec: number;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    unlockStake: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawStake: (args: {
+        withdrawAddress: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawTo: (args: {
+        withdrawAddress: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    handleOps: (args: {
+        ops: any[];
+        beneficiary: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    handleAggregatedOps: (args: {
+        opsPerAggregator: any[];
+        beneficiary: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    innerHandleOp: (args: {
+        callData: Hex;
+        opInfo: any;
+        context: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    delegateAndRevert: (args: {
+        target: Address;
+        data: Hex;
+        account?: Account | Address;
+    }) => Promise<void>;
+    getUserOpHash: (args: {
+        op: any;
+    }) => Promise<Hash>;
+    getSenderAddress: (args: {
+        initCode: Hex;
+    }) => Promise<Address>;
+    senderCreator: () => Promise<Address>;
+    incrementNonce: (args: {
+        key: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    nonceSequenceNumber: (args: {
+        sender: Address;
+        key: bigint;
+    }) => Promise<bigint>;
+    supportsInterface: (args: {
+        interfaceId: Hex;
+    }) => Promise<boolean>;
+    eip712Domain: () => Promise<any>;
+    getCurrentUserOpHash: () => Promise<Hash>;
+    getDomainSeparatorV4: () => Promise<Hex>;
+    getPackedUserOpTypeHash: () => Promise<Hex>;
+    version: EntryPointVersion;
+};
+export declare const entryPointActions: (address: Address, version?: EntryPointVersion) => (client: PublicClient | WalletClient) => EntryPointActions;