@aastar/sdk 0.16.6 → 0.16.8

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

@@ -0,0 +1,68 @@
+import { type Hex, type Address, type Chain } from 'viem';
+/**
+ * Interface definitions
+ */
+export interface ValidationParams {
+    rpcUrl: string;
+    chain: Chain;
+}
+export interface RoleValidationParams extends ValidationParams {
+    registryAddress: Address;
+    roleId: Hex;
+    userAddress: Address;
+}
+export interface BalanceValidationParams extends ValidationParams {
+    address: Address;
+    minBalance?: string;
+}
+export interface TokenBalanceValidationParams extends BalanceValidationParams {
+    tokenAddress: Address;
+}
+export interface DeploymentValidationParams extends ValidationParams {
+    contractAddress: Address;
+}
+export interface ValidationResult {
+    valid: boolean;
+    message?: string;
+    data?: any;
+}
+export interface AccountBalance {
+    address: Address;
+    eth: bigint;
+    gToken: bigint;
+    aPNTs: bigint;
+    xPNTs: bigint;
+}
+export declare class StateValidator {
+    /**
+     * Create PublicClient helper
+     */
+    private static createClient;
+    /**
+     * Batch fetch balances for multiple accounts
+     */
+    static getAccountBalances(params: {
+        rpcUrl: string;
+        chain: Chain;
+        addresses: Address[];
+        gTokenAddress?: Address;
+        aPNTsAddress?: Address;
+        xPNTsAddress?: Address;
+    }): Promise<AccountBalance[]>;
+    /**
+     * Role Validation
+     */
+    static validateRole(params: RoleValidationParams): Promise<ValidationResult>;
+    /**
+     * ETH Balance Validation
+     */
+    static validateETHBalance(params: BalanceValidationParams): Promise<ValidationResult>;
+    /**
+     * Token Balance Validation
+     */
+    static validateTokenBalance(params: TokenBalanceValidationParams): Promise<ValidationResult>;
+    /**
+     * Deployment Validation
+     */
+    static validateDeployment(params: DeploymentValidationParams): Promise<ValidationResult>;
+}

package/{packages/core/src/actions/StateValidator.ts → dist/core/src/actions/StateValidator.js}

@@ -1,165 +1,105 @@
-import { createPublicClient, http, type PublicClient, type Hex, type Address, type Chain, erc20Abi, formatEther } from 'viem';
-
-/**
- * Interface definitions
- */
-export interface ValidationParams {
-    rpcUrl: string;
-    chain: Chain;
-}
-
-export interface RoleValidationParams extends ValidationParams {
-    registryAddress: Address;
-    roleId: Hex;
-    userAddress: Address;
-}
-
-export interface BalanceValidationParams extends ValidationParams {
-    address: Address;
-    minBalance?: string;
-}
-
-export interface TokenBalanceValidationParams extends BalanceValidationParams {
-    tokenAddress: Address;
-}
-
-export interface DeploymentValidationParams extends ValidationParams {
-    contractAddress: Address;
-}
-
-export interface ValidationResult {
-    valid: boolean;
-    message?: string;
-    data?: any;
-}
-
-export interface AccountBalance {
-    address: Address;
-    eth: bigint;
-    gToken: bigint;
-    aPNTs: bigint;
-    xPNTs: bigint;
-}
-
+import { createPublicClient, http, erc20Abi, formatEther } from 'viem';
 export class StateValidator {
     /**
      * Create PublicClient helper
      */
-    private static createClient(params: ValidationParams): PublicClient {
+    static createClient(params) {
         return createPublicClient({
             chain: params.chain,
             transport: http(params.rpcUrl)
-        }) as unknown as PublicClient;
+        });
     }
-
     /**
      * Batch fetch balances for multiple accounts
      */
-    static async getAccountBalances(params: {
-        rpcUrl: string;
-        chain: Chain;
-        addresses: Address[];
-        gTokenAddress?: Address;
-        aPNTsAddress?: Address;
-        xPNTsAddress?: Address;
-    }): Promise<AccountBalance[]> {
+    static async getAccountBalances(params) {
         const client = this.createClient({ rpcUrl: params.rpcUrl, chain: params.chain });
-
-        const results = await Promise.all(
-            params.addresses.map(async (address) => {
-                const [eth, gToken, aPNTs, xPNTs] = await Promise.all([
-                    client.getBalance({ address }),
-                    params.gTokenAddress
-                        ? client.readContract({
-                              address: params.gTokenAddress,
-                              abi: erc20Abi,
-                              functionName: 'balanceOf',
-                              args: [address]
-                          }) as Promise<bigint>
-                        : Promise.resolve(0n),
-                    params.aPNTsAddress
-                        ? client.readContract({
-                              address: params.aPNTsAddress,
-                              abi: erc20Abi,
-                              functionName: 'balanceOf',
-                              args: [address]
-                          }) as Promise<bigint>
-                        : Promise.resolve(0n),
-                    params.xPNTsAddress
-                        ? client.readContract({
-                              address: params.xPNTsAddress,
-                              abi: erc20Abi,
-                              functionName: 'balanceOf',
-                              args: [address]
-                          }) as Promise<bigint>
-                        : Promise.resolve(0n)
-                ]);
-
-                return {
-                    address,
-                    eth,
-                    gToken,
-                    aPNTs,
-                    xPNTs
-                };
-            })
-        );
-
+        const results = await Promise.all(params.addresses.map(async (address) => {
+            const [eth, gToken, aPNTs, xPNTs] = await Promise.all([
+                client.getBalance({ address }),
+                params.gTokenAddress
+                    ? client.readContract({
+                        address: params.gTokenAddress,
+                        abi: erc20Abi,
+                        functionName: 'balanceOf',
+                        args: [address]
+                    })
+                    : Promise.resolve(0n),
+                params.aPNTsAddress
+                    ? client.readContract({
+                        address: params.aPNTsAddress,
+                        abi: erc20Abi,
+                        functionName: 'balanceOf',
+                        args: [address]
+                    })
+                    : Promise.resolve(0n),
+                params.xPNTsAddress
+                    ? client.readContract({
+                        address: params.xPNTsAddress,
+                        abi: erc20Abi,
+                        functionName: 'balanceOf',
+                        args: [address]
+                    })
+                    : Promise.resolve(0n)
+            ]);
+            return {
+                address,
+                eth,
+                gToken,
+                aPNTs,
+                xPNTs
+            };
+        }));
         return results;
     }
-
     /**
      * Role Validation
      */
-    static async validateRole(params: RoleValidationParams): Promise<ValidationResult> {
+    static async validateRole(params) {
         try {
             const client = this.createClient(params);
-            
             const hasRole = await client.readContract({
                 address: params.registryAddress,
                 abi: [{
-                    name: 'hasRole',
-                    type: 'function',
-                    stateMutability: 'view',
-                    inputs: [
-                        { name: 'roleId', type: 'bytes32' },
-                        { name: 'user', type: 'address' }
-                    ],
-                    outputs: [{ name: '', type: 'bool' }]
-                }],
+                        name: 'hasRole',
+                        type: 'function',
+                        stateMutability: 'view',
+                        inputs: [
+                            { name: 'roleId', type: 'bytes32' },
+                            { name: 'user', type: 'address' }
+                        ],
+                        outputs: [{ name: '', type: 'bool' }]
+                    }],
                 functionName: 'hasRole',
                 args: [params.roleId, params.userAddress]
-            }) as boolean;
-
+            });
             return {
                 valid: hasRole,
-                message: hasRole 
+                message: hasRole
                     ? `✅ User ${params.userAddress} has role ${params.roleId}`
                     : `❌ User ${params.userAddress} does NOT have role ${params.roleId}`,
                 data: { hasRole }
             };
-        } catch (error) {
+        }
+        catch (error) {
             return {
                 valid: false,
-                message: `❌ Role validation failed: ${(error as Error).message}`,
+                message: `❌ Role validation failed: ${error.message}`,
                 data: { error }
             };
         }
     }
-
     /**
      * ETH Balance Validation
      */
-    static async validateETHBalance(params: BalanceValidationParams): Promise<ValidationResult> {
+    static async validateETHBalance(params) {
         try {
             const client = this.createClient(params);
             const balance = await client.getBalance({ address: params.address });
             const balanceETH = Number(formatEther(balance));
-
             if (params.minBalance) {
                 const minBalanceWei = BigInt(Math.floor(parseFloat(params.minBalance) * 1e18));
                 const sufficient = balance >= minBalanceWei;
-
                 return {
                     valid: sufficient,
                     message: sufficient
@@ -168,41 +108,36 @@ export class StateValidator {
                     data: { balance, balanceETH, minBalance: params.minBalance }
                 };
             }
-
             return {
                 valid: true,
                 message: `ℹ️  ETH balance: ${balanceETH.toFixed(4)} ETH`,
                 data: { balance, balanceETH }
             };
-        } catch (error) {
+        }
+        catch (error) {
             return {
                 valid: false,
-                message: `❌ ETH balance validation failed: ${(error as Error).message}`,
+                message: `❌ ETH balance validation failed: ${error.message}`,
                 data: { error }
             };
         }
     }
-
     /**
      * Token Balance Validation
      */
-    static async validateTokenBalance(params: TokenBalanceValidationParams): Promise<ValidationResult> {
+    static async validateTokenBalance(params) {
         try {
             const client = this.createClient(params);
-            
             const balance = await client.readContract({
                 address: params.tokenAddress,
                 abi: erc20Abi,
                 functionName: 'balanceOf',
                 args: [params.address]
-            }) as bigint;
-
+            });
             const balanceToken = Number(formatEther(balance));
-
             if (params.minBalance) {
                 const minBalanceWei = BigInt(Math.floor(parseFloat(params.minBalance) * 1e18));
                 const sufficient = balance >= minBalanceWei;
-
                 return {
                     valid: sufficient,
                     message: sufficient
@@ -211,30 +146,28 @@ export class StateValidator {
                     data: { balance, balanceToken, minBalance: params.minBalance }
                 };
             }
-
             return {
                 valid: true,
                 message: `ℹ️  Token balance: ${balanceToken.toFixed(4)}`,
                 data: { balance, balanceToken }
             };
-        } catch (error) {
+        }
+        catch (error) {
             return {
                 valid: false,
-                message: `❌ Token balance validation failed: ${(error as Error).message}`,
+                message: `❌ Token balance validation failed: ${error.message}`,
                 data: { error }
             };
         }
     }
-
     /**
      * Deployment Validation
      */
-    static async validateDeployment(params: DeploymentValidationParams): Promise<ValidationResult> {
+    static async validateDeployment(params) {
         try {
             const client = this.createClient(params);
             const code = await client.getBytecode({ address: params.contractAddress });
             const isDeployed = code !== undefined && code !== '0x';
-
             return {
                 valid: isDeployed,
                 message: isDeployed
@@ -242,10 +175,11 @@ export class StateValidator {
                     : `❌ No contract found at ${params.contractAddress}`,
                 data: { code, isDeployed }
             };
-        } catch (error) {
+        }
+        catch (error) {
             return {
                 valid: false,
-                message: `❌ Deployment validation failed: ${(error as Error).message}`,
+                message: `❌ Deployment validation failed: ${error.message}`,
                 data: { error }
             };
         }

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

@@ -0,0 +1,55 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type AccountActions = {
+    execute: (args: {
+        dest: Address;
+        value: bigint;
+        func: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeBatch: (args: {
+        dest: Address[];
+        value: bigint[];
+        func: Hex[];
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getNonce: () => Promise<bigint>;
+    entryPoint: () => Promise<Address>;
+    addDeposit: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    withdrawDepositTo: (args: {
+        withdrawAddress: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getDeposit: () => Promise<bigint>;
+    owner: () => Promise<Address>;
+    initialize: (args: {
+        owner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    upgradeToAndCall: (args: {
+        newImplementation: Address;
+        data: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    proxiableUUID: () => Promise<Hex>;
+    supportsInterface: (args: {
+        interfaceId: Hex;
+    }) => Promise<boolean>;
+    UPGRADE_INTERFACE_VERSION: () => Promise<string>;
+};
+export type AccountFactoryActions = {
+    createAccount: (args: {
+        owner: Address;
+        salt: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getAddress: (args: {
+        owner: Address;
+        salt: bigint;
+    }) => Promise<Address>;
+    accountImplementation: () => Promise<Address>;
+};
+export declare const accountActions: (address: Address) => (client: PublicClient | WalletClient) => AccountActions;
+export declare const accountFactoryActions: (address: Address) => (client: PublicClient | WalletClient) => AccountFactoryActions;

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

@@ -0,0 +1,133 @@
+import { SimpleAccountABI, SimpleAccountFactoryABI } from '../abis/index.js';
+export const accountActions = (address) => (client) => ({
+    async execute({ dest, value, func, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'execute',
+            args: [dest, value, func],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async executeBatch({ dest, value, func, account }) {
+        // Zip arguments into Call[] struct format
+        const calls = dest.map((t, i) => ({
+            target: t,
+            value: value[i],
+            data: func[i]
+        }));
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'executeBatch',
+            args: [calls],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getNonce() {
+        return client.readContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'getNonce',
+            args: []
+        });
+    },
+    async entryPoint() {
+        return client.readContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'entryPoint',
+            args: []
+        });
+    },
+    async addDeposit({ account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'addDeposit',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async withdrawDepositTo({ withdrawAddress, amount, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'withdrawDepositTo',
+            args: [withdrawAddress, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getDeposit() {
+        return client.readContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'getDeposit',
+            args: []
+        });
+    },
+    async owner() {
+        return client.readContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async initialize({ owner, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'initialize',
+            args: [owner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async upgradeToAndCall({ newImplementation, data, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountABI,
+            functionName: 'upgradeToAndCall',
+            args: [newImplementation, data],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async proxiableUUID() {
+        return client.readContract({ address, abi: SimpleAccountABI, functionName: 'proxiableUUID', args: [] });
+    },
+    async supportsInterface({ interfaceId }) {
+        return client.readContract({ address, abi: SimpleAccountABI, functionName: 'supportsInterface', args: [interfaceId] });
+    },
+    async UPGRADE_INTERFACE_VERSION() {
+        return client.readContract({ address, abi: SimpleAccountABI, functionName: 'UPGRADE_INTERFACE_VERSION', args: [] });
+    }
+});
+export const accountFactoryActions = (address) => (client) => ({
+    async createAccount({ owner, salt, account }) {
+        return client.writeContract({
+            address,
+            abi: SimpleAccountFactoryABI,
+            functionName: 'createAccount',
+            args: [owner, salt],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getAddress({ owner, salt }) {
+        return client.readContract({
+            address,
+            abi: SimpleAccountFactoryABI,
+            functionName: 'getAddress',
+            args: [owner, salt]
+        });
+    },
+    async accountImplementation() {
+        return client.readContract({ address, abi: SimpleAccountFactoryABI, functionName: 'accountImplementation', args: [] });
+    }
+});

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

@@ -0,0 +1,17 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type AggregatorActions = {
+    registerBLSPublicKey: (args: {
+        address: Address;
+        publicKey: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setBLSThreshold: (args: {
+        address: Address;
+        threshold: number;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getBLSThreshold: (args: {
+        address: Address;
+    }) => Promise<bigint>;
+};
+export declare const aggregatorActions: () => (client: PublicClient | WalletClient) => AggregatorActions;

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

@@ -0,0 +1,31 @@
+import { BLSAggregatorABI } from '../abis/index.js';
+export const aggregatorActions = () => (client) => ({
+    async registerBLSPublicKey({ address, publicKey, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'registerBLSPublicKey',
+            args: [publicKey],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setBLSThreshold({ address, threshold, account }) {
+        return client.writeContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'setThreshold',
+            args: [BigInt(threshold)],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async getBLSThreshold({ address }) {
+        return client.readContract({
+            address,
+            abi: BLSAggregatorABI,
+            functionName: 'threshold',
+            args: []
+        });
+    }
+});

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

@@ -0,0 +1,30 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type DVTActions = {
+    createSlashProposal: (args: {
+        address: Address;
+        operator: Address;
+        level: number;
+        reason: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    signSlashProposal: (args: {
+        address: Address;
+        proposalId: bigint;
+        signature: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    executeSlashWithProof: (args: {
+        address: Address;
+        proposalId: bigint;
+        repUsers: Address[];
+        newScores: bigint[];
+        epoch: bigint;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    isValidator: (args: {
+        address: Address;
+        user: Address;
+    }) => Promise<boolean>;
+};
+export declare const dvtActions: () => (client: PublicClient | WalletClient) => DVTActions;