@aastar/dapp 0.16.8 → 0.16.11

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

@@ -1,90 +0,0 @@
-import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
-export declare enum EntryPointVersion {
-    V06 = "0.6",
-    V07 = "0.7"
-}
-export type EntryPointActions = {
-    balanceOf: (args: {
-        account: Address;
-    }) => Promise<bigint>;
-    depositTo: (args: {
-        account: Address;
-        amount: bigint;
-        txAccount?: Account | Address;
-    }) => Promise<Hash>;
-    getNonce: (args: {
-        sender: Address;
-        key: bigint;
-    }) => Promise<bigint>;
-    getDepositInfo: (args: {
-        account: Address;
-    }) => Promise<{
-        deposit: bigint;
-        staked: boolean;
-        stake: bigint;
-        unstakeDelaySec: number;
-        withdrawTime: number;
-    }>;
-    addStake: (args: {
-        unstakeDelaySec: number;
-        amount: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    unlockStake: (args: {
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    withdrawStake: (args: {
-        withdrawAddress: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    withdrawTo: (args: {
-        withdrawAddress: Address;
-        amount: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    handleOps: (args: {
-        ops: any[];
-        beneficiary: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    handleAggregatedOps: (args: {
-        opsPerAggregator: any[];
-        beneficiary: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    innerHandleOp: (args: {
-        callData: Hex;
-        opInfo: any;
-        context: Hex;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    delegateAndRevert: (args: {
-        target: Address;
-        data: Hex;
-        account?: Account | Address;
-    }) => Promise<void>;
-    getUserOpHash: (args: {
-        op: any;
-    }) => Promise<Hash>;
-    getSenderAddress: (args: {
-        initCode: Hex;
-    }) => Promise<Address>;
-    senderCreator: () => Promise<Address>;
-    incrementNonce: (args: {
-        key: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    nonceSequenceNumber: (args: {
-        sender: Address;
-        key: bigint;
-    }) => Promise<bigint>;
-    supportsInterface: (args: {
-        interfaceId: Hex;
-    }) => Promise<boolean>;
-    eip712Domain: () => Promise<any>;
-    getCurrentUserOpHash: () => Promise<Hash>;
-    getDomainSeparatorV4: () => Promise<Hex>;
-    getPackedUserOpTypeHash: () => Promise<Hex>;
-    version: EntryPointVersion;
-};
-export declare const entryPointActions: (address: Address, version?: EntryPointVersion) => (client: PublicClient | WalletClient) => EntryPointActions;

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

@@ -1,211 +0,0 @@
-import { EntryPointABI } from '../abis/index.js';
-export var EntryPointVersion;
-(function (EntryPointVersion) {
-    EntryPointVersion["V06"] = "0.6";
-    EntryPointVersion["V07"] = "0.7";
-})(EntryPointVersion || (EntryPointVersion = {}));
-export const entryPointActions = (address, version = EntryPointVersion.V07) => (client) => ({
-    version,
-    async balanceOf({ account }) {
-        // v0.6 and v0.7 both use balanceOf(address)
-        return client.readContract({
-            address,
-            abi: [{ name: 'balanceOf', inputs: [{ type: 'address' }], outputs: [{ type: 'uint256' }], type: 'function', stateMutability: 'view' }],
-            functionName: 'balanceOf',
-            args: [account]
-        });
-    },
-    async depositTo({ account, amount, txAccount }) {
-        // v0.6 and v0.7 both use depositTo(address)
-        return client.writeContract({
-            address,
-            abi: [{ name: 'depositTo', type: 'function', inputs: [{ type: 'address' }], outputs: [], stateMutability: 'payable' }],
-            functionName: 'depositTo',
-            args: [account],
-            value: amount,
-            account: txAccount,
-            chain: client.chain
-        });
-    },
-    async getNonce({ sender, key }) {
-        if (version === EntryPointVersion.V06) {
-            // v0.6: getNonce(address, uint192)
-            return client.readContract({
-                address,
-                abi: [{ name: 'getNonce', type: 'function', inputs: [{ type: 'address', name: 'sender' }, { type: 'uint256', name: 'key' }], outputs: [{ type: 'uint256' }], stateMutability: 'view' }],
-                functionName: 'getNonce',
-                args: [sender, key]
-            });
-        }
-        else {
-            // v0.7: getNonce(address, uint192) - Note: v0.7 actually uses 192 bit key but in ABI it's uint192
-            return client.readContract({
-                address,
-                abi: [{ name: 'getNonce', type: 'function', inputs: [{ type: 'address', name: 'sender' }, { type: 'uint192', name: 'key' }], outputs: [{ type: 'uint256' }], stateMutability: 'view' }],
-                functionName: 'getNonce',
-                args: [sender, key]
-            });
-        }
-    },
-    async getDepositInfo({ account }) {
-        const result = await client.readContract({
-            address,
-            abi: [{
-                    name: 'getDepositInfo',
-                    type: 'function',
-                    inputs: [{ type: 'address', name: 'account' }],
-                    outputs: [
-                        { type: 'uint112', name: 'deposit' },
-                        { type: 'bool', name: 'staked' },
-                        { type: 'uint112', name: 'stake' },
-                        { type: 'uint32', name: 'unstakeDelaySec' },
-                        { type: 'uint48', name: 'withdrawTime' }
-                    ],
-                    stateMutability: 'view'
-                }],
-            functionName: 'getDepositInfo',
-            args: [account]
-        });
-        return {
-            deposit: result[0],
-            staked: result[1],
-            stake: result[2],
-            unstakeDelaySec: result[3],
-            withdrawTime: result[4]
-        };
-    },
-    async addStake({ unstakeDelaySec, amount, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'addStake',
-            args: [unstakeDelaySec],
-            value: amount,
-            account: account,
-            chain: client.chain
-        });
-    },
-    async unlockStake({ account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'unlockStake',
-            args: [],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async withdrawStake({ withdrawAddress, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'withdrawStake',
-            args: [withdrawAddress],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async withdrawTo({ withdrawAddress, amount, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'withdrawTo',
-            args: [withdrawAddress, amount],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async handleOps({ ops, beneficiary, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'handleOps',
-            args: [ops, beneficiary],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async handleAggregatedOps({ opsPerAggregator, beneficiary, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'handleAggregatedOps',
-            args: [opsPerAggregator, beneficiary],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async innerHandleOp({ callData, opInfo, context, account }) {
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'innerHandleOp',
-            args: [callData, opInfo, context],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async delegateAndRevert({ target, data, account }) {
-        // This typically reverts, but we act as a writer
-        return client.writeContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'delegateAndRevert',
-            args: [target, data],
-            account: account,
-            chain: client.chain
-        });
-    },
-    async getUserOpHash({ op }) {
-        return client.readContract({
-            address,
-            abi: EntryPointABI,
-            functionName: 'getUserOpHash',
-            args: [op]
-        });
-    },
-    async getSenderAddress({ initCode }) {
-        // getSenderAddress usually reverts with the address. Viem might throw.
-        // But let's assume standard call first.
-        // Actually in EP v0.7 it might return if called off-chain or revert.
-        // We will try readContract. 
-        try {
-            return await client.readContract({
-                address,
-                abi: EntryPointABI,
-                functionName: 'getSenderAddress',
-                args: [initCode]
-            });
-        }
-        catch (e) {
-            // Extract address from error if needed, but for now just implementing the method call.
-            // Usually this method reverts with SenderAddressResult(address)
-            throw e;
-        }
-    },
-    async senderCreator() {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'senderCreator', args: [] });
-    },
-    async incrementNonce({ key, account }) {
-        return client.writeContract({ address, abi: EntryPointABI, functionName: 'incrementNonce', args: [key], account: account, chain: client.chain });
-    },
-    async nonceSequenceNumber({ sender, key }) {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'nonceSequenceNumber', args: [sender, key] });
-    },
-    async supportsInterface({ interfaceId }) {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'supportsInterface', args: [interfaceId] });
-    },
-    async eip712Domain() {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'eip712Domain', args: [] });
-    },
-    async getCurrentUserOpHash() {
-        // View that returns 'bytes32'
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'getCurrentUserOpHash', args: [] });
-    },
-    async getDomainSeparatorV4() {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'getDomainSeparatorV4', args: [] });
-    },
-    async getPackedUserOpTypeHash() {
-        return client.readContract({ address, abi: EntryPointABI, functionName: 'getPackedUserOpTypeHash', args: [] });
-    }
-});

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

@@ -1,215 +0,0 @@
-import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
-export type XPNTsFactoryActions = {
-    createToken: (args: {
-        name: string;
-        symbol: string;
-        community: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    deployForCommunity: (args: {
-        community: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    getTokenAddress: (args: {
-        community: Address;
-    }) => Promise<Address>;
-    predictAddress: (args: {
-        community: Address;
-        salt?: bigint;
-    }) => Promise<Address>;
-    isTokenDeployed: (args: {
-        community: Address;
-    }) => Promise<boolean>;
-    getCommunityByToken: (args: {
-        token: Address;
-    }) => Promise<Address>;
-    getAllTokens: () => Promise<Address[]>;
-    getTokenCount: () => Promise<bigint>;
-    deployedTokens: (args: {
-        index: bigint;
-    }) => Promise<Address>;
-    communityToToken: (args: {
-        community: Address;
-    }) => Promise<Address>;
-    setRegistry: (args: {
-        registry: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    setSuperPaymaster: (args: {
-        paymaster: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    setImplementation: (args: {
-        impl: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    getImplementation: () => Promise<Address>;
-    REGISTRY: () => Promise<Address>;
-    SUPER_PAYMASTER: () => Promise<Address>;
-    tokenImplementation: () => Promise<Address>;
-    xPNTsFactoryOwner: () => Promise<Address>;
-    transferXPNTsFactoryOwnership: (args: {
-        newOwner: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    renounceXPNTsFactoryOwnership: (args: {
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    deployxPNTsToken: (args: {
-        name: string;
-        symbol: string;
-        community: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    predictDepositAmount: (args: {
-        community: Address;
-        userCount: bigint;
-    }) => Promise<bigint>;
-    getPredictionParams: (args: {
-        community: Address;
-    }) => Promise<any>;
-    getDepositBreakdown: (args: {
-        community: Address;
-    }) => Promise<any>;
-    getAPNTsPrice: () => Promise<bigint>;
-    aPNTsPriceUSD: () => Promise<bigint>;
-    setIndustryMultiplier: (args: {
-        industry: string;
-        multiplier: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    setSuperPaymasterAddress: (args: {
-        paymaster: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    updateAPNTsPrice: (args: {
-        newPrice: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    updatePrediction: (args: {
-        community: Address;
-        userCount: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    updatePredictionCustom: (args: {
-        community: Address;
-        params: any;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    hasToken: (args: {
-        token: Address;
-    }) => Promise<boolean>;
-    getDeployedCount: () => Promise<bigint>;
-    industryMultipliers: (args: {
-        industry: string;
-    }) => Promise<bigint>;
-    getIndustryMultiplier: (args: {
-        industry: string;
-    }) => Promise<bigint>;
-    predictions: (args: {
-        community: Address;
-    }) => Promise<any>;
-    MIN_SUGGESTED_AMOUNT: () => Promise<bigint>;
-    DEFAULT_SAFETY_FACTOR: () => Promise<bigint>;
-    SUPERPAYMASTER: () => Promise<Address>;
-    xPNTsFactoryVersion: () => Promise<string>;
-};
-export type PaymasterFactoryActions = {
-    deployPaymaster: (args: {
-        owner: Address;
-        version?: string;
-        initData?: Hex;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    deployPaymasterDeterministic: (args: {
-        owner: Address;
-        version?: string;
-        initData?: Hex;
-        salt: Hex;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    predictPaymasterAddress: (args: {
-        owner: Address;
-        salt: Hex;
-    }) => Promise<Address>;
-    calculateAddress: (args: {
-        owner: Address;
-    }) => Promise<Address>;
-    getPaymaster: (args: {
-        owner: Address;
-    }) => Promise<Address>;
-    getPaymasterCount: () => Promise<bigint>;
-    getAllPaymasters: () => Promise<Address[]>;
-    isPaymasterDeployed: (args: {
-        owner: Address;
-    }) => Promise<boolean>;
-    hasPaymaster: (args: {
-        owner: Address;
-    }) => Promise<boolean>;
-    getPaymasterList: (args: {
-        offset: bigint;
-        limit: bigint;
-    }) => Promise<Address[]>;
-    paymasterList: (args: {
-        index: bigint;
-    }) => Promise<Address>;
-    totalDeployed: () => Promise<bigint>;
-    getOperatorByPaymaster: (args: {
-        paymaster: Address;
-    }) => Promise<Address>;
-    operatorByPaymaster: (args: {
-        paymaster: Address;
-    }) => Promise<Address>;
-    getPaymasterByOperator: (args: {
-        operator: Address;
-    }) => Promise<Address>;
-    paymasterByOperator: (args: {
-        operator: Address;
-    }) => Promise<Address>;
-    getPaymasterInfo: (args: {
-        paymaster: Address;
-    }) => Promise<any>;
-    hasImplementation: (args: {
-        version: string;
-    }) => Promise<boolean>;
-    implementations: (args: {
-        version: string;
-    }) => Promise<Address>;
-    setImplementationV4: (args: {
-        impl: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    getImplementationV4: () => Promise<Address>;
-    setRegistry: (args: {
-        registry: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    addImplementation: (args: {
-        version: string;
-        implementation: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    upgradeImplementation: (args: {
-        version: string;
-        newImplementation: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    setDefaultVersion: (args: {
-        version: string;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    REGISTRY: () => Promise<Address>;
-    ENTRY_POINT: () => Promise<Address>;
-    paymasterFactoryOwner: () => Promise<Address>;
-    transferPaymasterFactoryOwnership: (args: {
-        newOwner: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    renouncePaymasterFactoryOwnership: (args: {
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    defaultVersion: () => Promise<string>;
-    paymasterFactoryVersion: () => Promise<string>;
-};
-export declare const xPNTsFactoryActions: (address: Address) => (client: PublicClient | WalletClient) => XPNTsFactoryActions;
-export declare const paymasterFactoryActions: (address: Address) => (client: PublicClient | WalletClient) => PaymasterFactoryActions;