@aastar/core 0.16.7 → 0.16.11

package/dist/actions/tokens.js

@@ -1,415 +1,471 @@
 import { GTokenABI, xPNTsTokenABI } from '../abis/index.js';
-function getTokenABI(token) {
-    // Auto-detect ABI based on token type or use generic xPNTsTokenABI
-    return xPNTsTokenABI;
-}
-export const gTokenActions = () => (client) => ({
-    // Use GTokenABI for everything
-    ...tokenActions()(client),
-    async tokenTotalSupply({ token }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'totalSupply', args: [] });
-    },
-    async tokenBalanceOf({ token, account }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'balanceOf', args: [account] });
-    },
-    async tokenTransfer({ token, to, amount, account }) {
-        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'transfer', args: [to, amount], account: account, chain: client.chain });
-    },
-    async tokenTransferFrom({ token, from, to, amount, account }) {
-        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'transferFrom', args: [from, to, amount], account: account, chain: client.chain });
-    },
-    async tokenApprove({ token, spender, amount, account }) {
-        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'approve', args: [spender, amount], account: account, chain: client.chain });
-    },
-    async tokenAllowance({ token, owner, spender }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'allowance', args: [owner, spender] });
-    },
-    async tokenMint({ token, to, amount, account }) {
-        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'mint', args: [to, amount], account: account, chain: client.chain });
-    },
-    async tokenBurn({ token, amount, account }) {
-        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'burn', args: [amount], account: account, chain: client.chain });
-    },
-    async tokenBurnFrom({ token, from, amount, account }) {
-        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'burnFrom', args: [from, amount], account: account, chain: client.chain });
-    },
-    async tokenName({ token }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'name', args: [] });
-    },
-    async tokenSymbol({ token }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'symbol', args: [] });
-    },
-    async tokenDecimals({ token }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'decimals', args: [] });
-    },
-    async tokenOwner({ token }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'owner', args: [] });
-    },
-    async tokenTransferTokenOwnership({ token, newOwner, account }) {
-        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'transferOwnership', args: [newOwner], account: account, chain: client.chain });
-    },
-    async tokenRenounceOwnership({ token, account }) {
-        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'renounceOwnership', args: [], account: account, chain: client.chain });
-    },
-    async tokenCap({ token }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'cap', args: [] });
-    },
-    async tokenRemainingMintableSupply({ token }) {
-        return client.readContract({ address: token, abi: GTokenABI, functionName: 'remainingMintableSupply', args: [] });
-    },
-});
-export const tokenActions = () => (client) => ({
-    // ERC20 Standard
-    async tokenTotalSupply({ token }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'totalSupply',
-            args: []
-        });
-    },
-    async tokenCap({ token }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'cap',
-            args: []
-        });
-    },
-    async tokenRemainingMintableSupply({ token }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'remainingMintableSupply',
-            args: []
-        });
-    },
-    async tokenBalanceOf({ token, account }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'balanceOf',
-            args: [account]
-        });
-    },
-    async tokenTransfer({ token, to, amount, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'transfer',
-            args: [to, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenTransferFrom({ token, from, to, amount, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'transferFrom',
-            args: [from, to, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenApprove({ token, spender, amount, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'approve',
-            args: [spender, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenAllowance({ token, owner, spender }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'allowance',
-            args: [owner, spender]
-        });
-    },
-    // Mintable/Burnable
-    async tokenMint({ token, to, amount, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'mint',
-            args: [to, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenBurn({ token, amount, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'burn',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenBurnFrom({ token, from, amount, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'burnFrom',
-            args: [from, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // ERC20 Metadata
-    async tokenName({ token }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'name',
-            args: []
-        });
-    },
-    async tokenSymbol({ token }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'symbol',
-            args: []
-        });
-    },
-    async tokenDecimals({ token }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'decimals',
-            args: []
-        });
-    },
-    // Ownable
-    async tokenOwner({ token }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'owner',
-            args: []
-        });
-    },
-    async tokenTransferTokenOwnership({ token, newOwner, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'transferOwnership',
-            args: [newOwner],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenRenounceOwnership({ token, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'renounceOwnership',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // xPNTs/aPNTs specific
-    async tokenUpdateExchangeRate({ token, newRate, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'updateExchangeRate',
-            args: [newRate],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenGetDebt({ token, user }) {
-        return client.readContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'getDebt',
-            args: [user]
-        });
-    },
-    async tokenRepayDebt({ token, amount, account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'repayDebt',
-            args: [amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenTransferAndCall({ token, to, amount, data = '0x', account }) {
-        return client.writeContract({
-            address: token,
-            abi: getTokenABI(token),
-            functionName: 'transferAndCall',
-            args: [to, amount, data],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // Auto Approval
-    async tokenAddAutoApprovedSpender({ token, spender, account }) {
-        return client.writeContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'addAutoApprovedSpender',
-            args: [spender],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenRemoveAutoApprovedSpender({ token, spender, account }) {
-        return client.writeContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'removeAutoApprovedSpender',
-            args: [spender],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenIsAutoApprovedSpender({ token, spender }) {
-        return client.readContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'isAutoApprovedSpender',
-            args: [spender]
-        });
-    },
-    // Constants
-    async tokenSUPERPAYMASTER_ADDRESS({ token }) {
-        return client.readContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'SUPERPAYMASTER_ADDRESS',
-            args: []
-        });
-    },
-    async tokenFACTORY({ token }) {
-        return client.readContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'FACTORY',
-            args: []
-        });
-    },
-    async tokenTransferOwnership(args) {
-        return this.tokenTransferTokenOwnership(args);
-    },
-    async tokenTransferCommunityOwnership({ token, newOwner, account }) {
-        return client.writeContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'transferCommunityOwnership',
-            args: [newOwner],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // xPNTs Views
-    async tokenCommunityName({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'communityName', args: [] });
-    },
-    async tokenCommunityENS({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'communityENS', args: [] });
-    },
-    async tokenExchangeRate({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'exchangeRate', args: [] });
-    },
-    async tokenSpendingLimits({ token, user }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'spendingLimits', args: [user] });
-    },
-    async tokenDefaultSpendingLimitXPNTs({ token }) {
-        try {
-            return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'defaultSpendingLimitXPNTs', args: [] });
-        }
-        catch {
-            return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'getDefaultSpendingLimitXPNTs', args: [] });
-        }
-    },
-    async tokenCumulativeSpent({ token, user }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'cumulativeSpent', args: [user] });
-    },
-    async tokenDebts({ token, user }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'debts', args: [user] });
-    },
-    async tokenUsedOpHashes({ token, hash }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'usedOpHashes', args: [hash] });
-    },
-    // EIP2612
-    async tokenDOMAIN_SEPARATOR({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'DOMAIN_SEPARATOR', args: [] });
-    },
-    async tokenNonces({ token, owner }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'nonces', args: [owner] });
-    },
-    async tokenPermit({ token, owner, spender, value, deadline, v, r, s, account }) {
-        return client.writeContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'permit',
-            args: [owner, spender, value, deadline, v, r, s],
-            account: account,
-            chain: client.chain
-        });
-    },
-    // xPNTs Additional
-    async tokenAutoApprovedSpenders({ token, spender }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'autoApprovedSpenders', args: [spender] });
-    },
-    async tokenBurnFromWithOpHash({ token, account: user, amount, opHash, userOpAccount }) {
-        return client.writeContract({ address: token, abi: xPNTsTokenABI, functionName: 'burnFromWithOpHash', args: [user, amount, opHash], account: userOpAccount, chain: client.chain });
-    },
-    async tokenCommunityOwner({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'communityOwner', args: [] });
-    },
-    async tokenEip712Domain({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'eip712Domain', args: [] });
-    },
-    async tokenGetDefaultSpendingLimitXPNTs({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'getDefaultSpendingLimitXPNTs', args: [] });
-    },
-    async tokenGetMetadata({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'getMetadata', args: [] });
-    },
-    async tokenNeedsApproval({ token, owner, spender, amount }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'needsApproval', args: [owner, spender, amount] });
-    },
-    async tokenRecordDebt({ token, user, amount, account }) {
-        return client.writeContract({ address: token, abi: xPNTsTokenABI, functionName: 'recordDebt', args: [user, amount], account: account, chain: client.chain });
-    },
-    async tokenDEFAULT_SPENDING_LIMIT_APNTS({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'DEFAULT_SPENDING_LIMIT_APNTS', args: [] });
-    },
-    // Admin
-    async tokenSetPaymasterLimit({ token, user, limit, account }) {
-        return client.writeContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'setPaymasterLimit',
-            args: [user, limit],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenSetSuperPaymasterAddress({ token, superPaymaster, account }) {
-        return client.writeContract({
-            address: token,
-            abi: xPNTsTokenABI,
-            functionName: 'setSuperPaymasterAddress',
-            args: [superPaymaster],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async tokenVersion({ token }) {
-        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'version', args: [] });
-    }
-});
+import { validateAddress, validateAmount, validateRequired } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
+export const gTokenActions = (address) => (client) => {
+    const abi = GTokenABI;
+    const actions = {
+        async totalSupply({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'totalSupply', args: [] });
+        },
+        async balanceOf({ token = address, account }) {
+            validateAddress(token, 'token');
+            validateAddress(account, 'account');
+            return client.readContract({ address: token, abi, functionName: 'balanceOf', args: [account] });
+        },
+        async transfer({ token = address, to, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(to, 'to');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'transfer', args: [to, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'transfer');
+            }
+        },
+        async transferFrom({ token = address, from, to, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(from, 'from');
+                validateAddress(to, 'to');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'transferFrom', args: [from, to, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'transferFrom');
+            }
+        },
+        async approve({ token = address, spender, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(spender, 'spender');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'approve', args: [spender, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'approve');
+            }
+        },
+        async allowance({ token = address, owner, spender }) {
+            validateAddress(token, 'token');
+            validateAddress(owner, 'owner');
+            validateAddress(spender, 'spender');
+            return client.readContract({ address: token, abi, functionName: 'allowance', args: [owner, spender] });
+        },
+        async mint({ token = address, to, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(to, 'to');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'mint', args: [to, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'mint');
+            }
+        },
+        async burn({ token = address, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'burn', args: [amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'burn');
+            }
+        },
+        async burnFrom({ token = address, from, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(from, 'from');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'burnFrom', args: [from, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'burnFrom');
+            }
+        },
+        async cap({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'cap', args: [] });
+        },
+        async remainingMintableSupply({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'remainingMintableSupply', args: [] });
+        },
+        async name({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'name', args: [] });
+        },
+        async symbol({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'symbol', args: [] });
+        },
+        async decimals({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'decimals', args: [] });
+        },
+        async version({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'version', args: [] });
+        },
+        async owner({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'owner', args: [] });
+        },
+        async transferOwnership({ token = address, newOwner, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(newOwner, 'newOwner');
+                return await client.writeContract({ address: token, abi, functionName: 'transferOwnership', args: [newOwner], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'transferOwnership');
+            }
+        },
+        async renounceOwnership({ token = address, account }) {
+            try {
+                validateAddress(token, 'token');
+                return await client.writeContract({ address: token, abi, functionName: 'renounceOwnership', args: [], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'renounceOwnership');
+            }
+        },
+    };
+    return actions;
+};
+export const xPNTsTokenActions = (address) => (client) => {
+    const abi = xPNTsTokenABI;
+    const actions = {
+        async totalSupply({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'totalSupply', args: [] });
+        },
+        async balanceOf({ token = address, account }) {
+            validateAddress(token, 'token');
+            validateAddress(account, 'account');
+            return client.readContract({ address: token, abi, functionName: 'balanceOf', args: [account] });
+        },
+        async transfer({ token = address, to, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(to, 'to');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'transfer', args: [to, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'transfer');
+            }
+        },
+        async transferFrom({ token = address, from, to, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(from, 'from');
+                validateAddress(to, 'to');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'transferFrom', args: [from, to, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'transferFrom');
+            }
+        },
+        async approve({ token = address, spender, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(spender, 'spender');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'approve', args: [spender, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'approve');
+            }
+        },
+        async allowance({ token = address, owner, spender }) {
+            validateAddress(token, 'token');
+            validateAddress(owner, 'owner');
+            validateAddress(spender, 'spender');
+            return client.readContract({ address: token, abi, functionName: 'allowance', args: [owner, spender] });
+        },
+        async mint({ token = address, to, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(to, 'to');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'mint', args: [to, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'mint');
+            }
+        },
+        async burn({ token = address, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'burn', args: [amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'burn');
+            }
+        },
+        async burnFrom({ token = address, from, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(from, 'from');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'burn', args: [from, amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'burnFrom');
+            }
+        },
+        async burnFromWithOpHash({ token = address, from, amount, userOpHash, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(from, 'from');
+                validateAmount(amount, 'amount');
+                validateRequired(userOpHash, 'userOpHash');
+                return await client.writeContract({ address: token, abi, functionName: 'burnFromWithOpHash', args: [from, amount, userOpHash], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'burnFromWithOpHash');
+            }
+        },
+        async name({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'name', args: [] });
+        },
+        async symbol({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'symbol', args: [] });
+        },
+        async decimals({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'decimals', args: [] });
+        },
+        async version({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'version', args: [] });
+        },
+        async exchangeRate({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'exchangeRate', args: [] });
+        },
+        async updateExchangeRate({ token = address, newRate, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAmount(newRate, 'newRate');
+                return await client.writeContract({ address: token, abi, functionName: 'updateExchangeRate', args: [newRate], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'updateExchangeRate');
+            }
+        },
+        async debts({ token = address, user }) {
+            validateAddress(token, 'token');
+            validateAddress(user, 'user');
+            return await client.readContract({
+                address: token,
+                abi,
+                functionName: 'debts',
+                args: [user]
+            });
+        },
+        async getDebt({ token = address, user }) {
+            validateAddress(token, 'token');
+            validateAddress(user, 'user');
+            return client.readContract({ address: token, abi, functionName: 'getDebt', args: [user] });
+        },
+        async recordDebt({ token = address, user, amountXPNTs, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(user, 'user');
+                validateAmount(amountXPNTs, 'amountXPNTs');
+                return await client.writeContract({ address: token, abi, functionName: 'recordDebt', args: [user, amountXPNTs], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'recordDebt');
+            }
+        },
+        async repayDebt({ token = address, amount, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'repayDebt', args: [amount], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'repayDebt');
+            }
+        },
+        async spendingLimits({ token = address, owner, spender }) {
+            validateAddress(token, 'token');
+            validateAddress(owner, 'owner');
+            validateAddress(spender, 'spender');
+            return client.readContract({ address: token, abi, functionName: 'spendingLimits', args: [owner, spender] });
+        },
+        async cumulativeSpent({ token = address, owner, spender }) {
+            validateAddress(token, 'token');
+            validateAddress(owner, 'owner');
+            validateAddress(spender, 'spender');
+            return client.readContract({ address: token, abi, functionName: 'cumulativeSpent', args: [owner, spender] });
+        },
+        async setPaymasterLimit({ token = address, spender, limit, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(spender, 'spender');
+                validateAmount(limit, 'limit');
+                return await client.writeContract({ address: token, abi, functionName: 'setPaymasterLimit', args: [spender, limit], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'setPaymasterLimit');
+            }
+        },
+        async DEFAULT_SPENDING_LIMIT_APNTS({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'DEFAULT_SPENDING_LIMIT_APNTS', args: [] });
+        },
+        async getDefaultSpendingLimitXPNTs({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'getDefaultSpendingLimitXPNTs', args: [] });
+        },
+        async needsApproval({ token = address, owner, spender, amount }) {
+            validateAddress(token, 'token');
+            validateAddress(owner, 'owner');
+            validateAddress(spender, 'spender');
+            validateAmount(amount, 'amount');
+            return client.readContract({ address: token, abi, functionName: 'needsApproval', args: [owner, spender, amount] });
+        },
+        async addAutoApprovedSpender({ token = address, spender, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(spender, 'spender');
+                return await client.writeContract({ address: token, abi, functionName: 'addAutoApprovedSpender', args: [spender], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'addAutoApprovedSpender');
+            }
+        },
+        async removeAutoApprovedSpender({ token = address, spender, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(spender, 'spender');
+                return await client.writeContract({ address: token, abi, functionName: 'removeAutoApprovedSpender', args: [spender], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'removeAutoApprovedSpender');
+            }
+        },
+        async autoApprovedSpenders({ token = address, spender }) {
+            validateAddress(token, 'token');
+            validateAddress(spender, 'spender');
+            return client.readContract({ address: token, abi, functionName: 'autoApprovedSpenders', args: [spender] });
+        },
+        async DOMAIN_SEPARATOR({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'DOMAIN_SEPARATOR', args: [] });
+        },
+        async nonces({ token = address, owner }) {
+            validateAddress(token, 'token');
+            validateAddress(owner, 'owner');
+            return client.readContract({ address: token, abi, functionName: 'nonces', args: [owner] });
+        },
+        async permit({ token = address, owner, spender, value, deadline, v, r, s, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(owner, 'owner');
+                validateAddress(spender, 'spender');
+                validateAmount(value, 'value');
+                validateRequired(deadline, 'deadline');
+                return await client.writeContract({ address: token, abi, functionName: 'permit', args: [owner, spender, value, deadline, v, r, s], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'permit');
+            }
+        },
+        async eip712Domain({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'eip712Domain', args: [] });
+        },
+        async transferAndCall({ token = address, to, amount, data = '0x', account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(to, 'to');
+                validateAmount(amount, 'amount');
+                return await client.writeContract({ address: token, abi, functionName: 'transferAndCall', args: [to, amount, data], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'transferAndCall');
+            }
+        },
+        async communityENS({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'communityENS', args: [] });
+        },
+        async communityName({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'communityName', args: [] });
+        },
+        async communityOwner({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'communityOwner', args: [] });
+        },
+        async getMetadata({ token = address } = {}) {
+            const abi = xPNTsTokenABI;
+            const res = await client.readContract({
+                address: token,
+                abi,
+                functionName: 'getMetadata',
+                args: []
+            });
+            if (Array.isArray(res)) {
+                return {
+                    name: res[0],
+                    symbol: res[1],
+                    communityName: res[2],
+                    communityENS: res[3],
+                    communityOwner: res[4]
+                };
+            }
+            return res;
+        },
+        async transferCommunityOwnership({ token = address, newOwner, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(newOwner, 'newOwner');
+                return await client.writeContract({ address: token, abi, functionName: 'transferCommunityOwnership', args: [newOwner], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'transferCommunityOwnership');
+            }
+        },
+        async setSuperPaymasterAddress({ token = address, spAddress, account }) {
+            try {
+                validateAddress(token, 'token');
+                validateAddress(spAddress, 'spAddress');
+                return await client.writeContract({ address: token, abi, functionName: 'setSuperPaymasterAddress', args: [spAddress], account: account, chain: client.chain });
+            }
+            catch (error) {
+                throw AAStarError.fromViemError(error, 'setSuperPaymasterAddress');
+            }
+        },
+        async SUPERPAYMASTER_ADDRESS({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'SUPERPAYMASTER_ADDRESS', args: [] });
+        },
+        async FACTORY({ token = address } = {}) {
+            validateAddress(token, 'token');
+            return client.readContract({ address: token, abi, functionName: 'FACTORY', args: [] });
+        },
+        async usedOpHashes({ token = address, opHash }) {
+            validateAddress(token, 'token');
+            validateRequired(opHash, 'opHash');
+            return client.readContract({ address: token, abi, functionName: 'usedOpHashes', args: [opHash] });
+        },
+    };
+    return actions;
+};
+// Legacy compatibility
+export const tokenActions = (address) => (client) => {
+    // This is essentially xPNTsTokenActions for now as it's the more complex one
+    return xPNTsTokenActions(address)(client);
+};