@aastar/core 0.16.8 → 0.16.12

package/dist/actions/paymaster.js

@@ -0,0 +1,706 @@
+import { PaymasterABI } from '../abis/index.js';
+import { validateAddress, validateAmount, validatePositive, validateRequired } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
+export const paymasterActions = (address) => (client) => ({
+    // Deposit Management
+    async depositFor({ user, token, amount, account }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(token, 'token');
+            validatePositive(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'depositFor',
+                args: [user, token, amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'depositFor');
+        }
+    },
+    async withdraw({ token, amount, account }) {
+        try {
+            validateAddress(token, 'token');
+            validateAmount(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'withdraw',
+                args: [token, amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'withdraw');
+        }
+    },
+    async balances({ user, token }) {
+        try {
+            validateAddress(user, 'user');
+            validateAddress(token, 'token');
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'balances',
+                args: [user, token]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'balances');
+        }
+    },
+    async setTokenPrice({ token, price, account }) {
+        try {
+            validateAddress(token, 'token');
+            validateAmount(price, 'price');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'setTokenPrice',
+                args: [token, price],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setTokenPrice');
+        }
+    },
+    async setCachedPrice({ price, timestamp, account }) {
+        try {
+            validatePositive(price, 'price');
+            validatePositive(BigInt(timestamp), 'timestamp');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'setCachedPrice',
+                args: [price, timestamp],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setCachedPrice');
+        }
+    },
+    async tokenPrices({ token }) {
+        try {
+            validateAddress(token, 'token');
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'tokenPrices',
+                args: [token]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'tokenPrices');
+        }
+    },
+    // Validation
+    async validatePaymasterUserOp({ userOp, userOpHash, maxCost }) {
+        try {
+            validateRequired(userOp, 'userOp');
+            validateRequired(userOpHash, 'userOpHash');
+            validateAmount(maxCost, 'maxCost');
+            const result = await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'validatePaymasterUserOp',
+                args: [userOp, userOpHash, maxCost]
+            });
+            return { context: result[0], validationData: result[1] };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'validatePaymasterUserOp');
+        }
+    },
+    async postOp({ mode, context, actualGasCost, actualUserOpFeePerGas, account }) {
+        try {
+            validateRequired(mode, 'mode');
+            validateRequired(context, 'context');
+            validateAmount(actualGasCost, 'actualGasCost');
+            validateAmount(actualUserOpFeePerGas, 'actualUserOpFeePerGas');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'postOp',
+                args: [mode, context, actualGasCost, actualUserOpFeePerGas],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'postOp');
+        }
+    },
+    // Deposit & Withdrawal
+    async addDeposit({ account, value }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'addDeposit',
+                args: [],
+                account: account,
+                chain: client.chain,
+                value
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'addDeposit');
+        }
+    },
+    async withdrawTo({ to, amount, account }) {
+        try {
+            validateAddress(to, 'to');
+            validatePositive(amount, 'amount');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'withdrawTo',
+                args: [to, amount],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'withdrawTo');
+        }
+    },
+    async addStake({ unstakeDelaySec, account, value }) {
+        try {
+            validateRequired(unstakeDelaySec, 'unstakeDelaySec');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'addStake',
+                args: [unstakeDelaySec],
+                account: account,
+                chain: client.chain,
+                value
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'addStake');
+        }
+    },
+    async unlockStake({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'unlockStake',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'unlockStake');
+        }
+    },
+    async withdrawStake({ to, account }) {
+        try {
+            validateAddress(to, 'to');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'withdrawStake',
+                args: [to],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'withdrawStake');
+        }
+    },
+    // EntryPoint
+    async entryPoint() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'entryPoint',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'entryPoint');
+        }
+    },
+    // Ownership
+    async owner() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'owner',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'owner');
+        }
+    },
+    async transferOwnership({ newOwner, account }) {
+        try {
+            validateAddress(newOwner, 'newOwner');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'transferOwnership',
+                args: [newOwner],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'transferOwnership');
+        }
+    },
+    async renounceOwnership({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'renounceOwnership',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'renounceOwnership');
+        }
+    },
+    // Initialization & Configuration
+    async initialize({ _entryPoint, _owner, _treasury, _ethUsdPriceFeed, _serviceFeeRate, _maxGasCostCap, _priceStalenessThreshold, account }) {
+        try {
+            validateAddress(_entryPoint, 'entryPoint');
+            validateAddress(_owner, 'owner');
+            validateAddress(_treasury, 'treasury');
+            validateAddress(_ethUsdPriceFeed, 'ethUsdPriceFeed');
+            validateAmount(_serviceFeeRate, 'serviceFeeRate');
+            validateAmount(_maxGasCostCap, 'maxGasCostCap');
+            validateAmount(_priceStalenessThreshold, 'priceStalenessThreshold');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'initialize',
+                args: [_entryPoint, _owner, _treasury, _ethUsdPriceFeed, _serviceFeeRate, _maxGasCostCap, _priceStalenessThreshold],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'initialize');
+        }
+    },
+    async setTreasury({ treasury, account }) {
+        try {
+            validateAddress(treasury, 'treasury');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'setTreasury',
+                args: [treasury],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setTreasury');
+        }
+    },
+    async setServiceFeeRate({ _serviceFeeRate, account }) {
+        try {
+            validateAmount(_serviceFeeRate, 'serviceFeeRate');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'setServiceFeeRate',
+                args: [_serviceFeeRate],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setServiceFeeRate');
+        }
+    },
+    async setMaxGasCostCap({ _maxGasCostCap, account }) {
+        try {
+            validateAmount(_maxGasCostCap, 'maxGasCostCap');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'setMaxGasCostCap',
+                args: [_maxGasCostCap],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setMaxGasCostCap');
+        }
+    },
+    async setPriceStalenessThreshold({ _priceStalenessThreshold, account }) {
+        try {
+            validateAmount(_priceStalenessThreshold, 'priceStalenessThreshold');
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'setPriceStalenessThreshold',
+                args: [_priceStalenessThreshold],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setPriceStalenessThreshold');
+        }
+    },
+    // Pause/Unpause
+    async pause({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'pause',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'pause');
+        }
+    },
+    async unpause({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'unpause',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'unpause');
+        }
+    },
+    async paused() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'paused',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'paused');
+        }
+    },
+    // Price Management
+    async cachedPrice() {
+        try {
+            const result = await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'cachedPrice',
+                args: []
+            });
+            if (Array.isArray(result)) {
+                return { price: result[0], updatedAt: Number(result[1]) };
+            }
+            return {
+                price: result.price,
+                updatedAt: Number(result.updatedAt)
+            };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'cachedPrice');
+        }
+    },
+    async updatePrice({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'updatePrice',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'updatePrice');
+        }
+    },
+    async getRealtimeTokenCost({ gasCost, token }) {
+        try {
+            validateAmount(gasCost, 'gasCost');
+            validateAddress(token, 'token');
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'getRealtimeTokenCost',
+                args: [gasCost, token]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'getRealtimeTokenCost');
+        }
+    },
+    async calculateCost({ gasCost, token, useRealtime }) {
+        try {
+            validateAmount(gasCost, 'gasCost');
+            validateAddress(token, 'token');
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'calculateCost',
+                args: [gasCost, token, useRealtime]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'calculateCost');
+        }
+    },
+    // Registry Integration
+    async isActiveInRegistry() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'isActiveInRegistry',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'isActiveInRegistry');
+        }
+    },
+    async isRegistrySet() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'isRegistrySet',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'isRegistrySet');
+        }
+    },
+    async deactivateFromRegistry({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'deactivateFromRegistry',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'deactivateFromRegistry');
+        }
+    },
+    async registry() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'registry',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'registry');
+        }
+    },
+    // Configuration Getters
+    async ethUsdPriceFeed() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'ethUsdPriceFeed',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'ethUsdPriceFeed');
+        }
+    },
+    async serviceFeeRate() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'serviceFeeRate',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'serviceFeeRate');
+        }
+    },
+    async maxGasCostCap() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'maxGasCostCap',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'maxGasCostCap');
+        }
+    },
+    async priceStalenessThreshold() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'priceStalenessThreshold',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'priceStalenessThreshold');
+        }
+    },
+    async treasury() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'treasury',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'treasury');
+        }
+    },
+    async oracleDecimals() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'oracleDecimals',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'oracleDecimals');
+        }
+    },
+    async tokenDecimals({ token }) {
+        try {
+            validateAddress(token, 'token');
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'tokenDecimals',
+                args: [token]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'tokenDecimals');
+        }
+    },
+    // Constants
+    async MAX_ETH_USD_PRICE() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'MAX_ETH_USD_PRICE',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MAX_ETH_USD_PRICE');
+        }
+    },
+    async MIN_ETH_USD_PRICE() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'MIN_ETH_USD_PRICE',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MIN_ETH_USD_PRICE');
+        }
+    },
+    async MAX_GAS_TOKENS() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'MAX_GAS_TOKENS',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MAX_GAS_TOKENS');
+        }
+    },
+    async MAX_SBTS() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'MAX_SBTS',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MAX_SBTS');
+        }
+    },
+    async MAX_SERVICE_FEE() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'MAX_SERVICE_FEE',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MAX_SERVICE_FEE');
+        }
+    },
+    async version() {
+        try {
+            return await client.readContract({
+                address,
+                abi: PaymasterABI,
+                functionName: 'version',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'version');
+        }
+    }
+});