@aastar/core 0.16.7

package/dist/actions/tokens.js

@@ -0,0 +1,415 @@
+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: [] });
+    }
+});

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

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

package/dist/actions/tokens.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { tokenActions } from './tokens.js';
+describe('TokenActions', () => {
+    const MOCK_ADDR = '0x1111111111111111111111111111111111111111';
+    let mockPublicClient;
+    let mockWalletClient;
+    let actions;
+    beforeEach(() => {
+        mockPublicClient = {
+            readContract: vi.fn(),
+            simulateContract: vi.fn().mockResolvedValue({ request: {} }),
+            writeContract: vi.fn().mockResolvedValue('0xhash'),
+            sendTransaction: vi.fn().mockResolvedValue('0xhash')
+        };
+        mockWalletClient = {
+            writeContract: vi.fn().mockResolvedValue('0xhash'),
+            chain: { id: 1 }
+        };
+        actions = tokenActions()(mockPublicClient);
+    });
+    it('should read name', async () => {
+        mockPublicClient.readContract.mockResolvedValue('Test Token');
+        const name = await actions.tokenName({ token: MOCK_ADDR });
+        expect(name).toBe('Test Token');
+        expect(mockPublicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+            functionName: 'name'
+        }));
+    });
+    it('should read symbol', async () => {
+        mockPublicClient.readContract.mockResolvedValue('TT');
+        const symbol = await actions.tokenSymbol({ token: MOCK_ADDR });
+        expect(symbol).toBe('TT');
+    });
+    it('should transfer tokens', async () => {
+        const tx = await actions.tokenTransfer({
+            token: MOCK_ADDR,
+            to: MOCK_ADDR,
+            amount: 100n,
+            account: { address: MOCK_ADDR }
+        });
+        expect(tx).toBe('0xhash');
+    });
+    it('should handle transferFrom', async () => {
+        const tx = await actions.tokenTransferFrom({
+            token: MOCK_ADDR,
+            from: MOCK_ADDR,
+            to: MOCK_ADDR,
+            amount: 100n,
+            account: { address: MOCK_ADDR }
+        });
+        expect(tx).toBe('0xhash');
+    });
+});

package/dist/actions/validators.d.ts

@@ -0,0 +1,194 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type DVTActions = {
+    createProposal: (args: {
+        target: Address;
+        calldata: Hex;
+        description: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    signProposal: (args: {
+        proposalId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeWithProof: (args: {
+        proposalId: bigint;
+        signatures: Hex[];
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    cancelProposal: (args: {
+        proposalId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    isValidator: (args: {
+        validator: Address;
+    }) => Promise<boolean>;
+    addValidator: (args: {
+        validator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    removeValidator: (args: {
+        validator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getValidators: () => Promise<Address[]>;
+    getValidatorCount: () => Promise<bigint>;
+    getProposal: (args: {
+        proposalId: bigint;
+    }) => Promise<any>;
+    getProposalCount: () => Promise<bigint>;
+    getProposalState: (args: {
+        proposalId: bigint;
+    }) => Promise<number>;
+    getSignatureCount: (args: {
+        proposalId: bigint;
+    }) => Promise<bigint>;
+    hasVoted: (args: {
+        proposalId: bigint;
+        validator: Address;
+    }) => Promise<boolean>;
+    proposals: (args: {
+        proposalId: bigint;
+    }) => Promise<any>;
+    nextProposalId: () => Promise<bigint>;
+    threshold: () => Promise<bigint>;
+    setThreshold: (args: {
+        newThreshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setRegistry: (args: {
+        registry: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setBLSAggregator: (args: {
+        aggregator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    markProposalExecuted: (args: {
+        proposalId: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    BLS_AGGREGATOR: () => Promise<Address>;
+    owner: () => Promise<Address>;
+    transferOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    renounceOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    version: () => Promise<string>;
+};
+export type BLSAggregatorActions = {
+    registerBLSPublicKey: (args: {
+        publicKey: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    deregisterBLSPublicKey: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    updatePublicKey: (args: {
+        newKey: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    aggregateSignatures: (args: {
+        signatures: Hex[];
+    }) => Promise<Hex>;
+    verifyAggregatedSignature: (args: {
+        message: Hex;
+        aggregatedSignature: Hex;
+        publicKeys: Hex[];
+    }) => Promise<boolean>;
+    validateSignature: (args: {
+        message: Hex;
+        signature: Hex;
+        publicKey: Hex;
+    }) => Promise<boolean>;
+    executeProposal: (args: {
+        proposalId: bigint;
+        signatures: Hex[];
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    verifyAndExecute: (args: {
+        proposalId: bigint;
+        signatures: Hex[];
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getPublicKey: (args: {
+        address: Address;
+    }) => Promise<Hex>;
+    aggregatedSignatures: (args: {
+        requestId: bigint;
+    }) => Promise<any>;
+    getRequestStatus: (args: {
+        requestId: bigint;
+    }) => Promise<any>;
+    getOperatorId: (args: {
+        operator: Address;
+    }) => Promise<Hex>;
+    registerOperator: (args: {
+        operator: Address;
+        blsPublicKey: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getPublicKeys: (args: {
+        addresses: Address[];
+    }) => Promise<Hex[]>;
+    getAggregatedPublicKey: (args: {
+        addresses: Address[];
+    }) => Promise<Hex>;
+    isKeyRegistered: (args: {
+        address: Address;
+    }) => Promise<boolean>;
+    getRegisteredCount: () => Promise<bigint>;
+    blsPublicKeys: (args: {
+        address: Address;
+    }) => Promise<Hex[]>;
+    threshold: () => Promise<bigint>;
+    minThreshold: () => Promise<bigint>;
+    defaultThreshold: () => Promise<bigint>;
+    setThreshold: (args: {
+        newThreshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setMinThreshold: (args: {
+        newThreshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setDefaultThreshold: (args: {
+        newThreshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setRegistry: (args: {
+        registry: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setDVTValidator: (args: {
+        validator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setSuperPaymaster: (args: {
+        paymaster: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    renounceOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    REGISTRY: () => Promise<Address>;
+    DVT_VALIDATOR: () => Promise<Address>;
+    SUPERPAYMASTER: () => Promise<Address>;
+    MAX_VALIDATORS: () => Promise<bigint>;
+    executedProposals: (args: {
+        proposalId: bigint;
+    }) => Promise<boolean>;
+    proposalNonces: (args: {
+        proposalId: bigint;
+    }) => Promise<bigint>;
+    owner: () => Promise<Address>;
+    transferOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    version: () => Promise<string>;
+};
+export declare const dvtActions: (address: Address) => (client: PublicClient | WalletClient) => DVTActions;
+export declare const blsActions: (address: Address) => (client: PublicClient | WalletClient) => BLSAggregatorActions;