@aastar/core 0.16.7

package/dist/actions/entryPoint.js

@@ -0,0 +1,211 @@
+import { EntryPointABI } from '../abis/index.js';
+export var EntryPointVersion;
+(function (EntryPointVersion) {
+    EntryPointVersion["V06"] = "0.6";
+    EntryPointVersion["V07"] = "0.7";
+})(EntryPointVersion || (EntryPointVersion = {}));
+export const entryPointActions = (address, version = EntryPointVersion.V07) => (client) => ({
+    version,
+    async balanceOf({ account }) {
+        // v0.6 and v0.7 both use balanceOf(address)
+        return client.readContract({
+            address,
+            abi: [{ name: 'balanceOf', inputs: [{ type: 'address' }], outputs: [{ type: 'uint256' }], type: 'function', stateMutability: 'view' }],
+            functionName: 'balanceOf',
+            args: [account]
+        });
+    },
+    async depositTo({ account, amount, txAccount }) {
+        // v0.6 and v0.7 both use depositTo(address)
+        return client.writeContract({
+            address,
+            abi: [{ name: 'depositTo', type: 'function', inputs: [{ type: 'address' }], outputs: [], stateMutability: 'payable' }],
+            functionName: 'depositTo',
+            args: [account],
+            value: amount,
+            account: txAccount,
+            chain: client.chain
+        });
+    },
+    async getNonce({ sender, key }) {
+        if (version === EntryPointVersion.V06) {
+            // v0.6: getNonce(address, uint192)
+            return client.readContract({
+                address,
+                abi: [{ name: 'getNonce', type: 'function', inputs: [{ type: 'address', name: 'sender' }, { type: 'uint256', name: 'key' }], outputs: [{ type: 'uint256' }], stateMutability: 'view' }],
+                functionName: 'getNonce',
+                args: [sender, key]
+            });
+        }
+        else {
+            // v0.7: getNonce(address, uint192) - Note: v0.7 actually uses 192 bit key but in ABI it's uint192
+            return client.readContract({
+                address,
+                abi: [{ name: 'getNonce', type: 'function', inputs: [{ type: 'address', name: 'sender' }, { type: 'uint192', name: 'key' }], outputs: [{ type: 'uint256' }], stateMutability: 'view' }],
+                functionName: 'getNonce',
+                args: [sender, key]
+            });
+        }
+    },
+    async getDepositInfo({ account }) {
+        const result = await client.readContract({
+            address,
+            abi: [{
+                    name: 'getDepositInfo',
+                    type: 'function',
+                    inputs: [{ type: 'address', name: 'account' }],
+                    outputs: [
+                        { type: 'uint112', name: 'deposit' },
+                        { type: 'bool', name: 'staked' },
+                        { type: 'uint112', name: 'stake' },
+                        { type: 'uint32', name: 'unstakeDelaySec' },
+                        { type: 'uint48', name: 'withdrawTime' }
+                    ],
+                    stateMutability: 'view'
+                }],
+            functionName: 'getDepositInfo',
+            args: [account]
+        });
+        return {
+            deposit: result[0],
+            staked: result[1],
+            stake: result[2],
+            unstakeDelaySec: result[3],
+            withdrawTime: result[4]
+        };
+    },
+    async addStake({ unstakeDelaySec, amount, account }) {
+        return client.writeContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'addStake',
+            args: [unstakeDelaySec],
+            value: amount,
+            account: account,
+            chain: client.chain
+        });
+    },
+    async unlockStake({ account }) {
+        return client.writeContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'unlockStake',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async withdrawStake({ withdrawAddress, account }) {
+        return client.writeContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'withdrawStake',
+            args: [withdrawAddress],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async withdrawTo({ withdrawAddress, amount, account }) {
+        return client.writeContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'withdrawTo',
+            args: [withdrawAddress, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async handleOps({ ops, beneficiary, account }) {
+        return client.writeContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'handleOps',
+            args: [ops, beneficiary],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async handleAggregatedOps({ opsPerAggregator, beneficiary, account }) {
+        return client.writeContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'handleAggregatedOps',
+            args: [opsPerAggregator, beneficiary],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async innerHandleOp({ callData, opInfo, context, account }) {
+        return client.writeContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'innerHandleOp',
+            args: [callData, opInfo, context],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async delegateAndRevert({ target, data, account }) {
+        // This typically reverts, but we act as a writer
+        return client.writeContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'delegateAndRevert',
+            args: [target, data],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getUserOpHash({ op }) {
+        return client.readContract({
+            address,
+            abi: EntryPointABI,
+            functionName: 'getUserOpHash',
+            args: [op]
+        });
+    },
+    async getSenderAddress({ initCode }) {
+        // getSenderAddress usually reverts with the address. Viem might throw.
+        // But let's assume standard call first.
+        // Actually in EP v0.7 it might return if called off-chain or revert.
+        // We will try readContract. 
+        try {
+            return await client.readContract({
+                address,
+                abi: EntryPointABI,
+                functionName: 'getSenderAddress',
+                args: [initCode]
+            });
+        }
+        catch (e) {
+            // Extract address from error if needed, but for now just implementing the method call.
+            // Usually this method reverts with SenderAddressResult(address)
+            throw e;
+        }
+    },
+    async senderCreator() {
+        return client.readContract({ address, abi: EntryPointABI, functionName: 'senderCreator', args: [] });
+    },
+    async incrementNonce({ key, account }) {
+        return client.writeContract({ address, abi: EntryPointABI, functionName: 'incrementNonce', args: [key], account: account, chain: client.chain });
+    },
+    async nonceSequenceNumber({ sender, key }) {
+        return client.readContract({ address, abi: EntryPointABI, functionName: 'nonceSequenceNumber', args: [sender, key] });
+    },
+    async supportsInterface({ interfaceId }) {
+        return client.readContract({ address, abi: EntryPointABI, functionName: 'supportsInterface', args: [interfaceId] });
+    },
+    async eip712Domain() {
+        return client.readContract({ address, abi: EntryPointABI, functionName: 'eip712Domain', args: [] });
+    },
+    async getCurrentUserOpHash() {
+        // View that returns 'bytes32'
+        return client.readContract({ address, abi: EntryPointABI, functionName: 'getCurrentUserOpHash', args: [] });
+    },
+    async getDomainSeparatorV4() {
+        return client.readContract({ address, abi: EntryPointABI, functionName: 'getDomainSeparatorV4', args: [] });
+    },
+    async getPackedUserOpTypeHash() {
+        return client.readContract({ address, abi: EntryPointABI, functionName: 'getPackedUserOpTypeHash', args: [] });
+    }
+});

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

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

package/dist/actions/entryPoint.test.js

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { parseEther } from 'viem';
+import { entryPointActions, EntryPointVersion } from './entryPoint.js';
+describe('EntryPoint Actions', () => {
+    const mockEntryPointAddress = '0x0000000071727De22E5E9d8BAf0edAc6f37da032';
+    const MOCK_USER = '0x1234567890123456789012345678901234567890';
+    let mockPublicClient;
+    beforeEach(() => {
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+    });
+    describe('getDepositInfo', () => {
+        it('should get deposit info for account', async () => {
+            // EntryPoint returns array that gets destructured into object
+            const mockDepositArray = [
+                1000000000000000000n, // deposit
+                true, // staked
+                500000000000000000n, // stake
+                86400, // unstakeDelaySec
+                0 // withdrawTime
+            ];
+            mockPublicClient.readContract.mockResolvedValue(mockDepositArray);
+            const account = '0x1234567890123456789012345678901234567890';
+            const actions = entryPointActions(mockEntryPointAddress)(mockPublicClient);
+            const depositInfo = await actions.getDepositInfo({ account });
+            expect(depositInfo.deposit).toBe(1000000000000000000n);
+            expect(depositInfo.staked).toBe(true);
+            expect(depositInfo.stake).toBe(500000000000000000n);
+            expect(depositInfo.unstakeDelaySec).toBe(86400);
+            expect(depositInfo.withdrawTime).toBe(0);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'getDepositInfo',
+                args: [account],
+            }));
+        });
+        it('should handle zero deposit', async () => {
+            const mockDepositArray = [0n, false, 0n, 0, 0];
+            mockPublicClient.readContract.mockResolvedValue(mockDepositArray);
+            const account = '0xabcd1234567890123456789012345678901234ab';
+            const actions = entryPointActions(mockEntryPointAddress)(mockPublicClient);
+            const depositInfo = await actions.getDepositInfo({ account });
+            expect(depositInfo.deposit).toBe(0n);
+            expect(depositInfo.staked).toBe(false);
+        });
+    });
+    describe('getNonce', () => {
+        it('should get nonce for sender with key', async () => {
+            const expectedNonce = 5n;
+            mockPublicClient.readContract.mockResolvedValue(expectedNonce);
+            const sender = '0x2222222222222222222222222222222222222222';
+            const key = 0n;
+            const actions = entryPointActions(mockEntryPointAddress)(mockPublicClient);
+            const nonce = await actions.getNonce({ sender, key });
+            expect(nonce).toBe(expectedNonce);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'getNonce',
+                args: [sender, key],
+            }));
+        });
+        it('should handle different key spaces', async () => {
+            const expectedNonce = 0n;
+            mockPublicClient.readContract.mockResolvedValue(expectedNonce);
+            const sender = '0x3333333333333333333333333333333333333333';
+            const key = 123n;
+            const actions = entryPointActions(mockEntryPointAddress)(mockPublicClient);
+            const nonce = await actions.getNonce({ sender, key });
+            expect(nonce).toBe(expectedNonce);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+                args: [sender, key],
+            }));
+        });
+    });
+    describe('balanceOf', () => {
+        it('should get balance of account', async () => {
+            const expectedBalance = 2000000000000000000n; // 2 ETH
+            mockPublicClient.readContract.mockResolvedValue(expectedBalance);
+            const account = '0x4444444444444444444444444444444444444444';
+            const actions = entryPointActions(mockEntryPointAddress)(mockPublicClient);
+            const balance = await actions.balanceOf({ account });
+            expect(balance).toBe(expectedBalance);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'balanceOf',
+                args: [account],
+            }));
+        });
+        it('should handle zero balance', async () => {
+            const expectedBalance = 0n;
+            mockPublicClient.readContract.mockResolvedValue(expectedBalance);
+            const account = '0x5555555555555555555555555555555555555555';
+            const actions = entryPointActions(mockEntryPointAddress)(mockPublicClient);
+            const balance = await actions.balanceOf({ account });
+            expect(balance).toBe(0n);
+        });
+    });
+    describe('Version Handling', () => {
+        it('should include version in actions', () => {
+            const actions = entryPointActions(mockEntryPointAddress, EntryPointVersion.V07)(mockPublicClient);
+            expect(actions.version).toBe(EntryPointVersion.V07);
+        });
+        it('should default to V07', () => {
+            const actions = entryPointActions(mockEntryPointAddress)(mockPublicClient);
+            expect(actions.version).toBe(EntryPointVersion.V07);
+        });
+    });
+    describe('Contract Address', () => {
+        it('should use provided contract address', async () => {
+            const customAddress = '0x6666666666666666666666666666666666666666';
+            mockPublicClient.readContract.mockResolvedValue(1n);
+            const account = '0x7777777777777777777777777777777777777777';
+            const actions = entryPointActions(customAddress)(mockPublicClient);
+            await actions.balanceOf({ account });
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+                address: customAddress,
+            }));
+        });
+    });
+    describe('depositTo', () => {
+        it('should deposit to account', async () => {
+            const txHash = '0xhash';
+            mockPublicClient.writeContract = vi.fn().mockResolvedValue(txHash);
+            const actions = entryPointActions(mockEntryPointAddress)(mockPublicClient);
+            const result = await actions.depositTo({
+                account: MOCK_USER,
+                amount: parseEther('1'),
+                txAccount: MOCK_USER
+            });
+            expect(result).toBe(txHash);
+        });
+    });
+    describe('getNonce V06', () => {
+        it('should get nonce for V06', async () => {
+            mockPublicClient.readContract.mockResolvedValue(10n);
+            const actions = entryPointActions(mockEntryPointAddress, EntryPointVersion.V06)(mockPublicClient);
+            const nonce = await actions.getNonce({ sender: MOCK_USER, key: 0n });
+            expect(nonce).toBe(10n);
+        });
+    });
+});

package/dist/actions/factory.d.ts

@@ -0,0 +1,215 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type XPNTsFactoryActions = {
+    createToken: (args: {
+        name: string;
+        symbol: string;
+        community: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    deployForCommunity: (args: {
+        community: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getTokenAddress: (args: {
+        community: Address;
+    }) => Promise<Address>;
+    predictAddress: (args: {
+        community: Address;
+        salt?: bigint;
+    }) => Promise<Address>;
+    isTokenDeployed: (args: {
+        community: Address;
+    }) => Promise<boolean>;
+    getCommunityByToken: (args: {
+        token: Address;
+    }) => Promise<Address>;
+    getAllTokens: () => Promise<Address[]>;
+    getTokenCount: () => Promise<bigint>;
+    deployedTokens: (args: {
+        index: bigint;
+    }) => Promise<Address>;
+    communityToToken: (args: {
+        community: Address;
+    }) => Promise<Address>;
+    setRegistry: (args: {
+        registry: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setSuperPaymaster: (args: {
+        paymaster: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setImplementation: (args: {
+        impl: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getImplementation: () => Promise<Address>;
+    REGISTRY: () => Promise<Address>;
+    SUPER_PAYMASTER: () => Promise<Address>;
+    tokenImplementation: () => Promise<Address>;
+    xPNTsFactoryOwner: () => Promise<Address>;
+    transferXPNTsFactoryOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    renounceXPNTsFactoryOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    deployxPNTsToken: (args: {
+        name: string;
+        symbol: string;
+        community: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    predictDepositAmount: (args: {
+        community: Address;
+        userCount: bigint;
+    }) => Promise<bigint>;
+    getPredictionParams: (args: {
+        community: Address;
+    }) => Promise<any>;
+    getDepositBreakdown: (args: {
+        community: Address;
+    }) => Promise<any>;
+    getAPNTsPrice: () => Promise<bigint>;
+    aPNTsPriceUSD: () => Promise<bigint>;
+    setIndustryMultiplier: (args: {
+        industry: string;
+        multiplier: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setSuperPaymasterAddress: (args: {
+        paymaster: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updateAPNTsPrice: (args: {
+        newPrice: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updatePrediction: (args: {
+        community: Address;
+        userCount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updatePredictionCustom: (args: {
+        community: Address;
+        params: any;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    hasToken: (args: {
+        token: Address;
+    }) => Promise<boolean>;
+    getDeployedCount: () => Promise<bigint>;
+    industryMultipliers: (args: {
+        industry: string;
+    }) => Promise<bigint>;
+    getIndustryMultiplier: (args: {
+        industry: string;
+    }) => Promise<bigint>;
+    predictions: (args: {
+        community: Address;
+    }) => Promise<any>;
+    MIN_SUGGESTED_AMOUNT: () => Promise<bigint>;
+    DEFAULT_SAFETY_FACTOR: () => Promise<bigint>;
+    SUPERPAYMASTER: () => Promise<Address>;
+    xPNTsFactoryVersion: () => Promise<string>;
+};
+export type PaymasterFactoryActions = {
+    deployPaymaster: (args: {
+        owner: Address;
+        version?: string;
+        initData?: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    deployPaymasterDeterministic: (args: {
+        owner: Address;
+        version?: string;
+        initData?: Hex;
+        salt: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    predictPaymasterAddress: (args: {
+        owner: Address;
+        salt: Hex;
+    }) => Promise<Address>;
+    calculateAddress: (args: {
+        owner: Address;
+    }) => Promise<Address>;
+    getPaymaster: (args: {
+        owner: Address;
+    }) => Promise<Address>;
+    getPaymasterCount: () => Promise<bigint>;
+    getAllPaymasters: () => Promise<Address[]>;
+    isPaymasterDeployed: (args: {
+        owner: Address;
+    }) => Promise<boolean>;
+    hasPaymaster: (args: {
+        owner: Address;
+    }) => Promise<boolean>;
+    getPaymasterList: (args: {
+        offset: bigint;
+        limit: bigint;
+    }) => Promise<Address[]>;
+    paymasterList: (args: {
+        index: bigint;
+    }) => Promise<Address>;
+    totalDeployed: () => Promise<bigint>;
+    getOperatorByPaymaster: (args: {
+        paymaster: Address;
+    }) => Promise<Address>;
+    operatorByPaymaster: (args: {
+        paymaster: Address;
+    }) => Promise<Address>;
+    getPaymasterByOperator: (args: {
+        operator: Address;
+    }) => Promise<Address>;
+    paymasterByOperator: (args: {
+        operator: Address;
+    }) => Promise<Address>;
+    getPaymasterInfo: (args: {
+        paymaster: Address;
+    }) => Promise<any>;
+    hasImplementation: (args: {
+        version: string;
+    }) => Promise<boolean>;
+    implementations: (args: {
+        version: string;
+    }) => Promise<Address>;
+    setImplementationV4: (args: {
+        impl: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getImplementationV4: () => Promise<Address>;
+    setRegistry: (args: {
+        registry: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    addImplementation: (args: {
+        version: string;
+        implementation: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    upgradeImplementation: (args: {
+        version: string;
+        newImplementation: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setDefaultVersion: (args: {
+        version: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    REGISTRY: () => Promise<Address>;
+    ENTRY_POINT: () => Promise<Address>;
+    paymasterFactoryOwner: () => Promise<Address>;
+    transferPaymasterFactoryOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    renouncePaymasterFactoryOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    defaultVersion: () => Promise<string>;
+    paymasterFactoryVersion: () => Promise<string>;
+};
+export declare const xPNTsFactoryActions: (address: Address) => (client: PublicClient | WalletClient) => XPNTsFactoryActions;
+export declare const paymasterFactoryActions: (address: Address) => (client: PublicClient | WalletClient) => PaymasterFactoryActions;