@aastar/core 0.16.7

package/dist/actions/paymasterV4.test.js

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { paymasterV4Actions } from './paymasterV4.js';
+describe('PaymasterV4 Actions', () => {
+    const mockPaymasterAddress = '0x1234567890123456789012345678901234567890';
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_USER = '0x2222222222222222222222222222222222222222';
+    const MOCK_TOKEN = '0x3333333333333333333333333333333333333333';
+    const MOCK_SBT = '0x4444444444444444444444444444444444444444';
+    beforeEach(() => {
+        mockAccount = {
+            address: '0x1111111111111111111111111111111111111111',
+            type: 'json-rpc'
+        };
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+    describe('Deposit-Only Model', () => {
+        it('should deposit for user', async () => {
+            const txHash = '0xabc...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockWalletClient);
+            const result = await actions.paymasterV4DepositFor({
+                user: MOCK_USER,
+                token: MOCK_TOKEN,
+                amount: 1000n,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'depositFor',
+                args: [MOCK_USER, MOCK_TOKEN, 1000n],
+            }));
+        });
+        it('should withdraw tokens', async () => {
+            const txHash = '0xdef...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockWalletClient);
+            const result = await actions.paymasterV4Withdraw({
+                token: MOCK_TOKEN,
+                amount: 500n,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should get balance', async () => {
+            mockPublicClient.readContract.mockResolvedValue(1000n);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockPublicClient);
+            const balance = await actions.paymasterV4Balances({ user: MOCK_USER, token: MOCK_TOKEN });
+            expect(balance).toBe(1000n);
+        });
+    });
+    describe('Token Pricing', () => {
+        it('should set token price', async () => {
+            const txHash = '0xghi...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockWalletClient);
+            const result = await actions.paymasterV4SetTokenPrice({
+                token: MOCK_TOKEN,
+                price: 2000n,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should get token price', async () => {
+            mockPublicClient.readContract.mockResolvedValue(2000n);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockPublicClient);
+            const price = await actions.paymasterV4TokenPrices({ token: MOCK_TOKEN });
+            expect(price).toBe(2000n);
+        });
+    });
+    describe('Gas Token Management', () => {
+        it('should add gas token', async () => {
+            const txHash = '0xjkl...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockWalletClient);
+            const result = await actions.paymasterV4AddGasToken({
+                token: MOCK_TOKEN,
+                priceFeed: '0x5555555555555555555555555555555555555555',
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+        it('should get supported gas tokens', async () => {
+            const mockTokens = [MOCK_TOKEN];
+            mockPublicClient.readContract.mockResolvedValue(mockTokens);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockPublicClient);
+            const tokens = await actions.paymasterV4GetSupportedGasTokens();
+            expect(tokens).toEqual(mockTokens);
+        });
+        it('should check if gas token is supported', async () => {
+            mockPublicClient.readContract.mockResolvedValue(true);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockPublicClient);
+            const supported = await actions.paymasterV4IsGasTokenSupported({ token: MOCK_TOKEN });
+            expect(supported).toBe(true);
+        });
+    });
+    describe('SBT Management', () => {
+        it('should add SBT', async () => {
+            const txHash = '0xmno...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockWalletClient);
+            const result = await actions.paymasterV4AddSBT({ sbt: MOCK_SBT, account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should get supported SBTs', async () => {
+            const mockSBTs = [MOCK_SBT];
+            mockPublicClient.readContract.mockResolvedValue(mockSBTs);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockPublicClient);
+            const sbts = await actions.paymasterV4GetSupportedSBTs();
+            expect(sbts).toEqual(mockSBTs);
+        });
+        it('should check if SBT is supported', async () => {
+            mockPublicClient.readContract.mockResolvedValue(true);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockPublicClient);
+            const supported = await actions.paymasterV4IsSBTSupported({ sbt: MOCK_SBT });
+            expect(supported).toBe(true);
+        });
+    });
+    describe('Traditional Deposit/Withdraw', () => {
+        it('should deposit directly', async () => {
+            const txHash = '0xpqr...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockWalletClient);
+            const result = await actions.paymasterV4Deposit({ account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should withdraw to address', async () => {
+            const txHash = '0xstu...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockWalletClient);
+            const result = await actions.paymasterV4WithdrawTo({
+                to: MOCK_USER,
+                amount: 100n,
+                account: mockAccount
+            });
+            expect(result).toBe(txHash);
+        });
+    });
+    describe('Validation', () => {
+        it('should validate paymaster UserOp', async () => {
+            const mockResult = '0x...';
+            mockPublicClient.readContract.mockResolvedValue(mockResult);
+            const actions = paymasterV4Actions(mockPaymasterAddress)(mockPublicClient);
+            const result = await actions.paymasterV4ValidatePaymasterUserOp({
+                userOp: {},
+                userOpHash: '0xhash',
+                maxCost: 1000n
+            });
+            expect(result).toBe(mockResult);
+        });
+    });
+});

package/dist/actions/registry.d.ts

@@ -0,0 +1,246 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+import type { RoleConfig } from '../roles.js';
+export type RegistryActions = {
+    registryConfigureRole: (args: {
+        roleId: Hex;
+        config: RoleConfig;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryRegisterRole: (args: {
+        roleId: Hex;
+        user: Address;
+        data: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryRegisterRoleSelf: (args: {
+        roleId: Hex;
+        data: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryHasRole: (args: {
+        user: Address;
+        roleId: Hex;
+    }) => Promise<boolean>;
+    registryUnRegisterRole: (args: {
+        user: Address;
+        roleId: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryGetRoleConfig: (args: {
+        roleId: Hex;
+    }) => Promise<any>;
+    registrySetRoleLockDuration: (args: {
+        roleId: Hex;
+        duration: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registrySetRoleOwner: (args: {
+        roleId: Hex;
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryIsCommunityMember: (args: {
+        community: Address;
+        user: Address;
+    }) => Promise<boolean>;
+    registryCommunityByName: (args: {
+        name: string;
+    }) => Promise<Address>;
+    registryCommunityByENS: (args: {
+        ensName: string;
+    }) => Promise<Address>;
+    registryCommunityByNameV3: (args: {
+        name: string;
+    }) => Promise<Address>;
+    registryCommunityByENSV3: (args: {
+        ensName: string;
+    }) => Promise<Address>;
+    registryProposedRoleNames: (args: {
+        roleId: Hex;
+    }) => Promise<string>;
+    registryExecutedProposals: (args: {
+        proposalId: bigint;
+    }) => Promise<boolean>;
+    registryGetAccountCommunity: (args: {
+        account: Address;
+    }) => Promise<Address>;
+    registryLastReputationEpoch: () => Promise<bigint>;
+    registryIsReputationSource: (args: {
+        source: Address;
+    }) => Promise<boolean>;
+    registryRoleCounts: (args: {
+        roleId: Hex;
+    }) => Promise<bigint>;
+    registryRoleMembers: (args: {
+        roleId: Hex;
+        index: bigint;
+    }) => Promise<Address>;
+    registryRoleMemberIndex: (args: {
+        roleId: Hex;
+        user: Address;
+    }) => Promise<bigint>;
+    registryRoleMetadata: (args: {
+        roleId: Hex;
+        user?: Address;
+    }) => Promise<Hex>;
+    registryRoleStakes: (args: {
+        roleId: Hex;
+        user: Address;
+    }) => Promise<bigint>;
+    registryRoleSBTTokenIds: (args: {
+        roleId: Hex;
+        user: Address;
+    }) => Promise<bigint>;
+    registryUserRoles: (args: {
+        user: Address;
+        index: bigint;
+    }) => Promise<Hex>;
+    registryUserRoleCount: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    registryGlobalReputation: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    registryBatchUpdateGlobalReputation: (args: {
+        users: Address[];
+        scores: bigint[];
+        epoch: bigint;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryUpdateOperatorBlacklist: (args: {
+        operator: Address;
+        users: Address[];
+        statuses: boolean[];
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryIsOperatorBlacklisted: (args: {
+        operator: Address;
+    }) => Promise<boolean>;
+    registrySetBLSValidator: (args: {
+        validator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registrySetBLSAggregator: (args: {
+        aggregator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registrySetMySBT: (args: {
+        sbt: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registrySetSuperPaymaster: (args: {
+        paymaster: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registrySetStaking: (args: {
+        staking: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registrySetReputationSource: (args: {
+        source: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryBlsValidator: () => Promise<Address>;
+    registryBlsAggregator: () => Promise<Address>;
+    registryMySBT: () => Promise<Address>;
+    registrySuperPaymaster: () => Promise<Address>;
+    registryStaking: () => Promise<Address>;
+    registryReputationSource: () => Promise<Address>;
+    registryTransferOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryOwner: () => Promise<Address>;
+    registryRenounceOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryRoleConfigs: (args: {
+        roleId: Hex;
+    }) => Promise<any>;
+    registryGetRoleMemberCount: (args: {
+        roleId: Hex;
+    }) => Promise<bigint>;
+    registryLevelThresholds: (args: {
+        level: bigint;
+    }) => Promise<bigint>;
+    registryRoleLockDurations: (args: {
+        roleId: Hex;
+    }) => Promise<bigint>;
+    registryRoleOwners: (args: {
+        roleId: Hex;
+    }) => Promise<Address>;
+    registryGetRoleMembers: (args: {
+        roleId: Hex;
+    }) => Promise<Address[]>;
+    registryGetRoleUserCount: (args: {
+        roleId: Hex;
+    }) => Promise<bigint>;
+    registryGetUserRoles: (args: {
+        user: Address;
+    }) => Promise<Hex[]>;
+    registryExitRole: (args: {
+        roleId: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryCalculateExitFee: (args: {
+        roleId: Hex;
+        amount: bigint;
+    }) => Promise<bigint>;
+    registryAddLevelThreshold: (args: {
+        threshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registrySetLevelThreshold: (args: {
+        index: bigint;
+        threshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryAccountToUser: (args: {
+        account: Address;
+    }) => Promise<Address>;
+    registryGetCreditLimit: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    registrySetCreditTier: (args: {
+        level: bigint;
+        limit: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryCreditTierConfig: (args: {
+        level: bigint;
+    }) => Promise<bigint>;
+    registryAdminConfigureRole: (args: {
+        roleId: Hex;
+        minStake: bigint;
+        entryBurn: bigint;
+        exitFeePercent: number;
+        minExitFee: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryCreateNewRole: (args: {
+        roleId: Hex;
+        config: RoleConfig;
+        roleOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registrySafeMintForRole: (args: {
+        roleId: Hex;
+        user: Address;
+        data: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    registryROLE_COMMUNITY: () => Promise<Hex>;
+    registryROLE_ENDUSER: () => Promise<Hex>;
+    registryROLE_PAYMASTER_SUPER: () => Promise<Hex>;
+    registryROLE_PAYMASTER_AOA: () => Promise<Hex>;
+    registryROLE_DVT: () => Promise<Hex>;
+    registryROLE_KMS: () => Promise<Hex>;
+    registryROLE_ANODE: () => Promise<Hex>;
+    registryGTOKEN_STAKING: () => Promise<Address>;
+    registryMYSBT: () => Promise<Address>;
+    registrySUPER_PAYMASTER: () => Promise<Address>;
+    registryVersion: () => Promise<string>;
+};
+export declare const registryActions: (address: Address) => (client: PublicClient | WalletClient) => RegistryActions;