@aastar/dapp 0.16.7

package/dist/core/src/actions/factory.js

@@ -0,0 +1,442 @@
+import { parseEther } from 'viem';
+import { xPNTsFactoryABI, PaymasterFactoryABI } from '../abis/index.js';
+export const xPNTsFactoryActions = (address) => (client) => ({
+    async createToken({ name, symbol, community, account }) {
+        // Map to deployxPNTsToken
+        // Args: name, symbol, communityName, communityENS, exchangeRate, paymasterAOA
+        // We use name/symbol as community name/ens placeholder if not provided
+        // We assume msg.sender (account) is the community owner
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'deployxPNTsToken',
+            args: [
+                name,
+                symbol,
+                name, // communityName
+                symbol, // communityENS
+                parseEther('1'), // exchangeRate: 1:1 with 18 decimals (1e18)
+                '0x0000000000000000000000000000000000000000' // paymasterAOA
+            ],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async deployForCommunity({ community, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'deployForCommunity',
+            args: [community],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getTokenAddress({ community }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getTokenAddress',
+            args: [community]
+        });
+    },
+    async predictAddress({ community, salt }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'predictAddress',
+            args: salt !== undefined ? [community, salt] : [community]
+        });
+    },
+    async isTokenDeployed({ community }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'isTokenDeployed',
+            args: [community]
+        });
+    },
+    async getCommunityByToken({ token }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getCommunityByToken',
+            args: [token]
+        });
+    },
+    async getAllTokens() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getAllTokens',
+            args: []
+        });
+    },
+    async getTokenCount() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getTokenCount',
+            args: []
+        });
+    },
+    async deployedTokens({ index }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'deployedTokens',
+            args: [index]
+        });
+    },
+    async communityToToken({ community }) {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'communityToToken',
+            args: [community]
+        });
+    },
+    async setRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setSuperPaymaster({ paymaster, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'setSuperPaymaster',
+            args: [paymaster],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setImplementation({ impl, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'setImplementation',
+            args: [impl],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getImplementation() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'getImplementation',
+            args: []
+        });
+    },
+    async REGISTRY() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    async tokenImplementation() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'tokenImplementation',
+            args: []
+        });
+    },
+    async xPNTsFactoryOwner() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async transferXPNTsFactoryOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async renounceXPNTsFactoryOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async deployxPNTsToken(args) {
+        return this.createToken(args);
+    },
+    // Prediction & Economics
+    async predictDepositAmount({ community, userCount }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'predictDepositAmount', args: [community, userCount] });
+    },
+    async getPredictionParams({ community }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'getPredictionParams', args: [community] });
+    },
+    async getDepositBreakdown({ community }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'getDepositBreakdown', args: [community] });
+    },
+    async getAPNTsPrice() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'getAPNTsPrice', args: [] });
+    },
+    async aPNTsPriceUSD() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'aPNTsPriceUSD', args: [] });
+    },
+    async SUPER_PAYMASTER() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'SUPER_PAYMASTER', args: [] });
+    },
+    async SUPERPAYMASTER() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'SUPERPAYMASTER', args: [] });
+    },
+    // Admin & Config
+    async setIndustryMultiplier({ industry, multiplier, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'setIndustryMultiplier', args: [industry, multiplier], account: account, chain: client.chain });
+    },
+    async setSuperPaymasterAddress({ paymaster, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'setSuperPaymasterAddress', args: [paymaster], account: account, chain: client.chain });
+    },
+    async updateAPNTsPrice({ newPrice, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'updateAPNTsPrice', args: [newPrice], account: account, chain: client.chain });
+    },
+    async updatePrediction({ community, userCount, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'updatePrediction', args: [community, userCount], account: account, chain: client.chain });
+    },
+    async updatePredictionCustom({ community, params, account }) {
+        return client.writeContract({ address, abi: xPNTsFactoryABI, functionName: 'updatePredictionCustom', args: [community, params], account: account, chain: client.chain });
+    },
+    // Views
+    async hasToken({ token }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'hasToken', args: [token] });
+    },
+    async getDeployedCount() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'getDeployedCount', args: [] });
+    },
+    async industryMultipliers({ industry }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'industryMultipliers', args: [industry] });
+    },
+    async getIndustryMultiplier({ industry }) {
+        return this.industryMultipliers({ industry });
+    },
+    async predictions({ community }) {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'predictions', args: [community] });
+    },
+    // Constants
+    async DEFAULT_SAFETY_FACTOR() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'DEFAULT_SAFETY_FACTOR', args: [] });
+    },
+    async MIN_SUGGESTED_AMOUNT() {
+        return client.readContract({ address, abi: xPNTsFactoryABI, functionName: 'MIN_SUGGESTED_AMOUNT', args: [] });
+    },
+    async xPNTsFactoryVersion() {
+        return client.readContract({
+            address,
+            abi: xPNTsFactoryABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});
+export const paymasterFactoryActions = (address) => (client) => ({
+    async deployPaymaster({ owner, version, initData, account }) {
+        // Factory.deployPaymaster(version, initData)
+        const defaultVer = 'v4.2'; // 当前标准版本
+        const useVer = version || defaultVer;
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'deployPaymaster',
+            args: [useVer, initData || '0x'],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async deployPaymasterDeterministic({ owner, version, initData, salt, account }) {
+        return client.writeContract({ address, abi: PaymasterFactoryABI, functionName: 'deployPaymasterDeterministic', args: [version || 'v4.2', initData || '0x', salt], account: account, chain: client.chain });
+    },
+    async predictPaymasterAddress({ owner, salt }) {
+        // Note: Contract might not have this function exposed directly or it is separate logic
+        // But ABI says it's missing, so let's try calling it if it exists in ABI
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'predictPaymasterAddress', args: [owner, salt] });
+    },
+    async calculateAddress({ owner }) {
+        // This function doesn't exist in V4 factory for non-deterministic deploy
+        // We throw to avoid misleading usage
+        throw new Error('Predicting address not supported for standard deploy. Use getPaymaster after deploy.');
+    },
+    async getPaymaster({ owner }) {
+        // 使用 paymasterByOperator mapping（不支持 salt）
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'paymasterByOperator',
+            args: [owner]
+        });
+    },
+    async getPaymasterCount() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'getPaymasterCount',
+            args: []
+        });
+    },
+    async getAllPaymasters() {
+        // Not directly supported by contract as single call (it has list + pagination), using pagination shim
+        const count = await client.readContract({
+            address, abi: PaymasterFactoryABI, functionName: 'getPaymasterCount', args: []
+        });
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'getPaymasterList',
+            args: [0n, count]
+        });
+    },
+    async isPaymasterDeployed({ owner }) {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'hasPaymaster', // Corrected from isPaymasterDeployed
+            args: [owner]
+        });
+    },
+    async hasPaymaster({ owner }) { return this.isPaymasterDeployed({ owner }); },
+    async getPaymasterList({ offset, limit }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'getPaymasterList', args: [offset, limit] });
+    },
+    async paymasterList({ index }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'paymasterList', args: [index] });
+    },
+    async totalDeployed() {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'totalDeployed', args: [] });
+    },
+    async getOperatorByPaymaster({ paymaster }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'getOperatorByPaymaster', args: [paymaster] });
+    },
+    async operatorByPaymaster({ paymaster }) { return this.getOperatorByPaymaster({ paymaster }); },
+    async getPaymasterByOperator({ operator }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'getPaymasterByOperator', args: [operator] });
+    },
+    async paymasterByOperator({ operator }) { return this.getPaymasterByOperator({ operator }); },
+    async getPaymasterInfo({ paymaster }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'getPaymasterInfo', args: [paymaster] });
+    },
+    async hasImplementation({ version }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'hasImplementation', args: [version] });
+    },
+    async implementations({ version }) {
+        return client.readContract({ address, abi: PaymasterFactoryABI, functionName: 'implementations', args: [version] });
+    },
+    async setImplementationV4({ impl, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'setImplementationV4',
+            args: [impl],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getImplementationV4() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'getImplementationV4',
+            args: []
+        });
+    },
+    async setRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async addImplementation({ version, implementation, account }) {
+        return client.writeContract({ address, abi: PaymasterFactoryABI, functionName: 'addImplementation', args: [version, implementation], account: account, chain: client.chain });
+    },
+    async upgradeImplementation({ version, newImplementation, account }) {
+        return client.writeContract({ address, abi: PaymasterFactoryABI, functionName: 'upgradeImplementation', args: [version, newImplementation], account: account, chain: client.chain });
+    },
+    async setDefaultVersion({ version, account }) {
+        return client.writeContract({ address, abi: PaymasterFactoryABI, functionName: 'setDefaultVersion', args: [version], account: account, chain: client.chain });
+    },
+    async REGISTRY() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    async ENTRY_POINT() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'ENTRY_POINT',
+            args: []
+        });
+    },
+    async paymasterFactoryOwner() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async transferPaymasterFactoryOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async renouncePaymasterFactoryOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async defaultVersion() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'defaultVersion',
+            args: []
+        });
+    },
+    async paymasterFactoryVersion() {
+        return client.readContract({
+            address,
+            abi: PaymasterFactoryABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});

package/dist/core/src/actions/faucet.d.ts

@@ -0,0 +1,48 @@
+import { type Address, type WalletClient, type PublicClient } from 'viem';
+export declare class SepoliaFaucetAPI {
+    /**
+     * Orchestrates the complete setup for a test account.
+     * 1. Funds ETH
+     * 2. Registers ENDUSER role
+     * 3. Mints potential Paymaster Tokens (cPNTs/dPNTs)
+     * 4. Deposits to Paymaster V4 (if address provided) using Admin's tokens
+     */
+    static prepareTestAccount(adminWallet: WalletClient, publicClient: PublicClient, config: {
+        targetAA: Address;
+        token: Address;
+        registry: Address;
+        paymasterV4?: Address;
+        superPaymaster?: Address;
+        ethAmount?: bigint;
+        tokenAmount?: bigint;
+        community?: Address;
+    }): Promise<{
+        ethFunded: boolean;
+        roleRegistered: boolean;
+        tokenMinted: boolean;
+        paymasterDeposited: boolean;
+    }>;
+    /**
+     * Funds the target with ETH if balance is below threshold.
+     */
+    static fundETH(adminWallet: WalletClient, publicClient: PublicClient, target: Address, amount: bigint): Promise<boolean>;
+    /**
+     * Registers the ENDUSER role via Registry.
+     */
+    /**
+     * Registers the ENDUSER role using Sponsor Mode (Admin pays stake).
+     */
+    static registerEndUser(adminWallet: WalletClient, publicClient: PublicClient, registryAddr: Address, target: Address, gasToken: Address, // Re-using the 'token' passed in config which is GToken
+    community?: Address): Promise<boolean>;
+    /**
+     * Mints tokens directly to the target.
+     */
+    static mintTestTokens(adminWallet: WalletClient, publicClient: PublicClient, token: Address, target: Address, amount: bigint): Promise<boolean>;
+    /**
+     * Complex Flow:
+     * 1. Admin mints tokens to SELF.
+     * 2. Admin approves Paymaster.
+     * 3. Admin calls depositFor(target) on Paymaster.
+     */
+    static adminDepositForUser(adminWallet: WalletClient, publicClient: PublicClient, paymaster: Address, target: Address, token: Address, amount: bigint): Promise<boolean>;
+}