@aastar/core 0.16.7

package/dist/actions/gtokenExtended.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { gTokenExtendedActions } from './gtokenExtended.js';
+describe('GTokenExtended Actions', () => {
+    const mockGTokenAddress = '0x1234567890123456789012345678901234567890';
+    let mockPublicClient;
+    let mockWalletClient;
+    let mockAccount;
+    const MOCK_USER = '0x2222222222222222222222222222222222222222';
+    beforeEach(() => {
+        mockAccount = {
+            address: '0x1111111111111111111111111111111111111111',
+            type: 'json-rpc'
+        };
+        mockPublicClient = {
+            readContract: vi.fn(),
+        };
+        mockWalletClient = {
+            writeContract: vi.fn(),
+            account: mockAccount,
+        };
+    });
+    describe('Minting & Burning', () => {
+        it('should mint tokens', async () => {
+            const txHash = '0xabc...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockWalletClient);
+            const result = await actions.mint({ to: MOCK_USER, amount: 1000n, account: mockAccount });
+            expect(result).toBe(txHash);
+            expect(mockWalletClient.writeContract).toHaveBeenCalledWith(expect.objectContaining({
+                functionName: 'mint',
+                args: [MOCK_USER, 1000n],
+            }));
+        });
+        it('should burn tokens', async () => {
+            const txHash = '0xdef...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockWalletClient);
+            const result = await actions.burn({ amount: 500n, account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should burn tokens from address', async () => {
+            const txHash = '0xghi...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockWalletClient);
+            const result = await actions.burnFrom({ from: MOCK_USER, amount: 500n, account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+    });
+    describe('Cap & Minter', () => {
+        it('should get cap', async () => {
+            mockPublicClient.readContract.mockResolvedValue(1000000n);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockPublicClient);
+            const cap = await actions.cap();
+            expect(cap).toBe(1000000n);
+        });
+        it('should get minter', async () => {
+            const mockMinter = '0x3333333333333333333333333333333333333333';
+            mockPublicClient.readContract.mockResolvedValue(mockMinter);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockPublicClient);
+            const minter = await actions.minter();
+            expect(minter).toBe(mockMinter);
+        });
+        it('should set minter', async () => {
+            const txHash = '0xjkl...';
+            const newMinter = '0x4444444444444444444444444444444444444444';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockWalletClient);
+            const result = await actions.setMinter({ minter: newMinter, account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+    });
+    describe('Pause', () => {
+        it('should pause', async () => {
+            const txHash = '0xmno...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockWalletClient);
+            const result = await actions.pause({ account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should unpause', async () => {
+            const txHash = '0xpqr...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockWalletClient);
+            const result = await actions.unpause({ account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should check if paused', async () => {
+            mockPublicClient.readContract.mockResolvedValue(true);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockPublicClient);
+            const isPaused = await actions.paused();
+            expect(isPaused).toBe(true);
+        });
+    });
+    describe('Ownership', () => {
+        it('should get owner', async () => {
+            const mockOwner = '0x5555555555555555555555555555555555555555';
+            mockPublicClient.readContract.mockResolvedValue(mockOwner);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockPublicClient);
+            const owner = await actions.owner();
+            expect(owner).toBe(mockOwner);
+        });
+        it('should transfer ownership', async () => {
+            const txHash = '0xstu...';
+            const newOwner = '0x6666666666666666666666666666666666666666';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockWalletClient);
+            const result = await actions.transferOwnership({ newOwner, account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+        it('should renounce ownership', async () => {
+            const txHash = '0xvwx...';
+            mockWalletClient.writeContract.mockResolvedValue(txHash);
+            const actions = gTokenExtendedActions(mockGTokenAddress)(mockWalletClient);
+            const result = await actions.renounceOwnership({ account: mockAccount });
+            expect(result).toBe(txHash);
+        });
+    });
+});

package/dist/actions/index.d.ts

@@ -0,0 +1,15 @@
+export * from './registry.js';
+export * from './staking.js';
+export * from './sbt.js';
+export * from './superPaymaster.js';
+export * from './paymasterV4.js';
+export * from './reputation.js';
+export * from './tokens.js';
+export * from './entryPoint.js';
+export * from './gtokenExtended.js';
+export * from './StateValidator.js';
+export * from './dvt.js';
+export * from './factory.js';
+export * from './aggregator.js';
+export * from './account.js';
+export * from './faucet.js';

package/dist/actions/index.js

@@ -0,0 +1,17 @@
+export * from './registry.js';
+export * from './staking.js';
+export * from './sbt.js';
+export * from './superPaymaster.js';
+export * from './paymasterV4.js';
+export * from './reputation.js';
+export * from './tokens.js';
+export * from './entryPoint.js';
+export * from './gtokenExtended.js';
+export * from './StateValidator.js';
+export * from './dvt.js';
+export * from './factory.js';
+export * from './aggregator.js';
+export * from './account.js';
+export * from './faucet.js';
+// validators.ts merged into dvt.js and aggregator.js
+// validators.ts merged into dvt.js and aggregator.js

package/dist/actions/paymasterV4.d.ts

@@ -0,0 +1,170 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type PaymasterV4Actions = {
+    paymasterV4DepositFor: (args: {
+        user: Address;
+        token: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4Withdraw: (args: {
+        token: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4Balances: (args: {
+        user: Address;
+        token: Address;
+    }) => Promise<bigint>;
+    paymasterV4SetTokenPrice: (args: {
+        token: Address;
+        price: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4TokenPrices: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    /** @deprecated V4 uses depositFor + tokenPrices instead */
+    paymasterV4AddGasToken: (args: {
+        token: Address;
+        priceFeed: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /** @deprecated V4 uses depositFor + tokenPrices instead */
+    paymasterV4RemoveGasToken: (args: {
+        token: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /** @deprecated V4 uses depositFor + tokenPrices instead */
+    paymasterV4GetSupportedGasTokens: () => Promise<Address[]>;
+    /** @deprecated V4 uses depositFor + tokenPrices instead */
+    paymasterV4IsGasTokenSupported: (args: {
+        token: Address;
+    }) => Promise<boolean>;
+    /** @deprecated V4 does not use SBT whitelist */
+    paymasterV4AddSBT: (args: {
+        sbt: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /** @deprecated V4 does not use SBT whitelist */
+    paymasterV4RemoveSBT: (args: {
+        sbt: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /** @deprecated V4 does not use SBT whitelist */
+    paymasterV4GetSupportedSBTs: () => Promise<Address[]>;
+    /** @deprecated V4 does not use SBT whitelist */
+    paymasterV4IsSBTSupported: (args: {
+        sbt: Address;
+    }) => Promise<boolean>;
+    paymasterV4ValidatePaymasterUserOp: (args: {
+        userOp: any;
+        userOpHash: Hex;
+        maxCost: bigint;
+    }) => Promise<any>;
+    paymasterV4PostOp: (args: {
+        mode: number;
+        context: Hex;
+        actualGasCost: bigint;
+        actualUserOpFeePerGas: bigint;
+    }) => Promise<void>;
+    paymasterV4Deposit: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4WithdrawTo: (args: {
+        to: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4AddStake: (args: {
+        unstakeDelaySec: bigint;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4UnlockPaymasterStake: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4WithdrawStake: (args: {
+        to: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4GetDeposit: () => Promise<bigint>;
+    paymasterV4EntryPoint: () => Promise<Address>;
+    paymasterV4Owner: () => Promise<Address>;
+    paymasterV4TransferOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4RenounceOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4Registry: () => Promise<Address>;
+    paymasterV4Treasury: () => Promise<Address>;
+    paymasterV4Paused: () => Promise<boolean>;
+    paymasterV4MaxGasCostCap: () => Promise<bigint>;
+    paymasterV4MaxEthUsdPrice: () => Promise<bigint>;
+    paymasterV4MaxGasTokens: () => Promise<bigint>;
+    paymasterV4MaxSbts: () => Promise<bigint>;
+    paymasterV4MaxServiceFee: () => Promise<bigint>;
+    paymasterV4MinEthUsdPrice: () => Promise<bigint>;
+    paymasterV4PriceStalenessThreshold: () => Promise<bigint>;
+    paymasterV4AddDeposit: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4UnlockStake: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4EthUsdPriceFeed: () => Promise<Address>;
+    paymasterV4OracleDecimals: () => Promise<number>;
+    paymasterV4TokenDecimals: (args: {
+        token: Address;
+    }) => Promise<number>;
+    paymasterV4ServiceFeeRate: () => Promise<bigint>;
+    paymasterV4CalculateCost: (args: {
+        token: Address;
+        gasCost: bigint;
+        param: any;
+    }) => Promise<bigint>;
+    paymasterV4GetRealtimeTokenCost: (args: {
+        token: Address;
+        gasCost: bigint;
+    }) => Promise<bigint>;
+    paymasterV4IsActiveInRegistry: () => Promise<boolean>;
+    paymasterV4IsRegistrySet: () => Promise<boolean>;
+    paymasterV4CachedPriceView: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    paymasterV4SetCachedPrice: (args: {
+        token: Address;
+        price: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4SetServiceFeeRate: (args: {
+        rate: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4SetMaxGasCostCap: (args: {
+        cap: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4SetPriceStalenessThreshold: (args: {
+        threshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4SetTreasury: (args: {
+        treasury: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4UpdatePrice: (args: {
+        token: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4DeactivateFromRegistry: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4Initialize: (args: {
+        owner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    paymasterV4Version: () => Promise<string>;
+};
+export declare const paymasterV4Actions: (address: Address) => (client: PublicClient | WalletClient) => PaymasterV4Actions;

package/dist/actions/paymasterV4.js

@@ -0,0 +1,334 @@
+import { PaymasterV4ABI } from '../abis/index.js';
+export const paymasterV4Actions = (address) => (client) => ({
+    // === NEW: Deposit-Only Model ===
+    async paymasterV4DepositFor({ user, token, amount, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'depositFor',
+            args: [user, token, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4Withdraw({ token, amount, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'withdraw',
+            args: [token, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4Balances({ user, token }) {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'balances',
+            args: [user, token]
+        });
+    },
+    async paymasterV4SetTokenPrice({ token, price, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'setTokenPrice',
+            args: [token, price],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4TokenPrices({ token }) {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'tokenPrices',
+            args: [token]
+        });
+    },
+    // === DEPRECATED: Legacy Gas Token Management ===
+    async paymasterV4AddGasToken({ token, priceFeed, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'addGasToken',
+            args: [token, priceFeed],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4RemoveGasToken({ token, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'removeGasToken',
+            args: [token],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4GetSupportedGasTokens() {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'getSupportedGasTokens',
+            args: []
+        });
+    },
+    async paymasterV4IsGasTokenSupported({ token }) {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'isGasTokenSupported',
+            args: [token]
+        });
+    },
+    // SBT Management
+    async paymasterV4AddSBT({ sbt, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'addSBT',
+            args: [sbt],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4RemoveSBT({ sbt, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'removeSBT',
+            args: [sbt],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4GetSupportedSBTs() {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'getSupportedSBTs',
+            args: []
+        });
+    },
+    async paymasterV4IsSBTSupported({ sbt }) {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'isSBTSupported',
+            args: [sbt]
+        });
+    },
+    // Validation
+    async paymasterV4ValidatePaymasterUserOp({ userOp, userOpHash, maxCost }) {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'validatePaymasterUserOp',
+            args: [userOp, userOpHash, maxCost]
+        });
+    },
+    async paymasterV4PostOp({ mode, context, actualGasCost, actualUserOpFeePerGas }) {
+        throw new Error('postOp is called by EntryPoint, not directly invoked');
+    },
+    // Deposit & Withdrawal (EntryPoint accounting)
+    async paymasterV4Deposit({ account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'deposit',
+            args: [],
+            account: account,
+            chain: client.chain,
+            value: 0n // Assuming non-payable or handled elsewhere if payable
+        });
+    },
+    async paymasterV4WithdrawTo({ to, amount, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'withdrawTo',
+            args: [to, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4AddStake({ unstakeDelaySec, amount, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'addStake',
+            args: [unstakeDelaySec],
+            value: amount,
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4UnlockPaymasterStake({ account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'unlockStake',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4WithdrawStake({ to, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'withdrawStake',
+            args: [to],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4GetDeposit() {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'getDeposit',
+            args: []
+        });
+    },
+    // EntryPoint
+    async paymasterV4EntryPoint() {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'entryPoint',
+            args: []
+        });
+    },
+    // Ownership
+    async paymasterV4Owner() {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async paymasterV4TransferOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async paymasterV4RenounceOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // View Functions & Constants
+    async paymasterV4Registry() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'registry', args: [] });
+    },
+    async paymasterV4Treasury() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'treasury', args: [] });
+    },
+    async paymasterV4Paused() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'paused', args: [] });
+    },
+    async paymasterV4MaxGasCostCap() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'maxGasCostCap', args: [] });
+    },
+    async paymasterV4MaxEthUsdPrice() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'MAX_ETH_USD_PRICE', args: [] });
+    },
+    async paymasterV4MaxGasTokens() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'MAX_GAS_TOKENS', args: [] });
+    },
+    async paymasterV4MaxSbts() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'MAX_SBTS', args: [] });
+    },
+    async paymasterV4MaxServiceFee() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'MAX_SERVICE_FEE', args: [] });
+    },
+    async paymasterV4MinEthUsdPrice() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'MIN_ETH_USD_PRICE', args: [] });
+    },
+    async paymasterV4PriceStalenessThreshold() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'priceStalenessThreshold', args: [] });
+    },
+    // Aliases
+    async paymasterV4AddDeposit(args) {
+        return this.paymasterV4Deposit(args);
+    },
+    async paymasterV4UnlockStake(args) {
+        return this.paymasterV4UnlockPaymasterStake(args);
+    },
+    // View Functions & Constants (Missing)
+    async paymasterV4EthUsdPriceFeed() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'ethUsdPriceFeed', args: [] });
+    },
+    async paymasterV4OracleDecimals() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'oracleDecimals', args: [] });
+    },
+    async paymasterV4TokenDecimals({ token }) {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'tokenDecimals', args: [token] });
+    },
+    async paymasterV4ServiceFeeRate() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'serviceFeeRate', args: [] });
+    },
+    async paymasterV4CalculateCost({ token, gasCost, param }) {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'calculateCost', args: [token, gasCost, param] });
+    },
+    async paymasterV4GetRealtimeTokenCost({ token, gasCost }) {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'getRealtimeTokenCost', args: [token, gasCost] });
+    },
+    async paymasterV4IsActiveInRegistry() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'isActiveInRegistry', args: [] });
+    },
+    async paymasterV4IsRegistrySet() {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'isRegistrySet', args: [] });
+    },
+    async paymasterV4CachedPriceView({ token }) {
+        return client.readContract({ address, abi: PaymasterV4ABI, functionName: 'cachedPrice', args: [token] });
+    },
+    // Admin (Missing)
+    async paymasterV4SetCachedPrice({ token, price, account }) {
+        return client.writeContract({ address, abi: PaymasterV4ABI, functionName: 'setCachedPrice', args: [token, price], account: account, chain: client.chain });
+    },
+    async paymasterV4SetServiceFeeRate({ rate, account }) {
+        return client.writeContract({ address, abi: PaymasterV4ABI, functionName: 'setServiceFeeRate', args: [rate], account: account, chain: client.chain });
+    },
+    async paymasterV4SetMaxGasCostCap({ cap, account }) {
+        return client.writeContract({ address, abi: PaymasterV4ABI, functionName: 'setMaxGasCostCap', args: [cap], account: account, chain: client.chain });
+    },
+    async paymasterV4SetPriceStalenessThreshold({ threshold, account }) {
+        return client.writeContract({ address, abi: PaymasterV4ABI, functionName: 'setPriceStalenessThreshold', args: [threshold], account: account, chain: client.chain });
+    },
+    async paymasterV4SetTreasury({ treasury, account }) {
+        return client.writeContract({ address, abi: PaymasterV4ABI, functionName: 'setTreasury', args: [treasury], account: account, chain: client.chain });
+    },
+    async paymasterV4UpdatePrice({ token, account }) {
+        return client.writeContract({ address, abi: PaymasterV4ABI, functionName: 'updatePrice', args: [token], account: account, chain: client.chain });
+    },
+    async paymasterV4DeactivateFromRegistry({ account }) {
+        return client.writeContract({ address, abi: PaymasterV4ABI, functionName: 'deactivateFromRegistry', args: [], account: account, chain: client.chain });
+    },
+    async paymasterV4Initialize({ owner, account }) {
+        return client.writeContract({ address, abi: PaymasterV4ABI, functionName: 'initialize', args: [owner], account: account, chain: client.chain });
+    },
+    async paymasterV4Version() {
+        return client.readContract({
+            address,
+            abi: PaymasterV4ABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});

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

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