@aastar/sdk 0.16.6 → 0.16.8

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

@@ -0,0 +1,41 @@
+import { DVTValidatorABI } from '../abis/index.js';
+export const dvtActions = () => (client) => ({
+    async createSlashProposal({ address, operator, level, reason, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'createProposal',
+            args: [operator, level, reason],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async signSlashProposal({ address, proposalId, signature, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'signProposal',
+            args: [proposalId, signature],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async executeSlashWithProof({ address, proposalId, repUsers, newScores, epoch, proof, account }) {
+        return client.writeContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'executeWithProof',
+            args: [proposalId, repUsers, newScores, epoch, proof],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async isValidator({ address, user }) {
+        return client.readContract({
+            address,
+            abi: DVTValidatorABI,
+            functionName: 'isValidator',
+            args: [user]
+        });
+    }
+});

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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,211 @@
+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

@@ -0,0 +1,215 @@
+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;