@aastar/core 0.16.8 → 0.16.11

package/dist/actions/aggregator.d.ts

@@ -1,17 +1,78 @@
 import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
 export type AggregatorActions = {
     registerBLSPublicKey: (args: {
-        address: Address;
+        validator: Address;
         publicKey: Hex;
         account?: Account | Address;
     }) => Promise<Hash>;
-    setBLSThreshold: (args: {
-        address: Address;
-        threshold: number;
+    blsPublicKeys: (args: {
+        validator: Address;
+    }) => Promise<{
+        publicKey: Hex;
+        isActive: boolean;
+    }>;
+    setDefaultThreshold: (args: {
+        newThreshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setMinThreshold: (args: {
+        newThreshold: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    defaultThreshold: () => Promise<bigint>;
+    minThreshold: () => Promise<bigint>;
+    executeProposal: (args: {
+        proposalId: bigint;
+        target: Address;
+        callData: Hex;
+        requiredThreshold: bigint;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    verifyAndExecute: (args: {
+        proposalId: bigint;
+        operator: Address;
+        slashLevel: number;
+        repUsers: Address[];
+        newScores: bigint[];
+        epoch: bigint;
+        proof: Hex;
         account?: Account | Address;
     }) => Promise<Hash>;
-    getBLSThreshold: (args: {
-        address: Address;
+    executedProposals: (args: {
+        proposalId: bigint;
+    }) => Promise<boolean>;
+    proposalNonces: (args: {
+        proposalId: bigint;
     }) => Promise<bigint>;
+    aggregatedSignatures: (args: {
+        index: bigint;
+    }) => Promise<{
+        aggregatedSig: Hex;
+        messageHash: Hex;
+        timestamp: bigint;
+        verified: boolean;
+    }>;
+    setDVTValidator: (args: {
+        dv: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setSuperPaymaster: (args: {
+        paymaster: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    DVT_VALIDATOR: () => Promise<Address>;
+    SUPERPAYMASTER: () => Promise<Address>;
+    REGISTRY: () => Promise<Address>;
+    MAX_VALIDATORS: () => Promise<bigint>;
+    owner: () => Promise<Address>;
+    transferOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    renounceOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    version: () => Promise<string>;
 };
-export declare const aggregatorActions: () => (client: PublicClient | WalletClient) => AggregatorActions;
+export declare const aggregatorActions: (address: Address) => (client: PublicClient | WalletClient) => AggregatorActions;

package/dist/actions/aggregator.js

@@ -1,31 +1,331 @@
 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: []
-        });
+import { validateAddress, validateRequired } from '../validators/index.js';
+import { AAStarError } from '../errors/index.js';
+export const aggregatorActions = (address) => (client) => ({
+    // BLS Public Key Management
+    async registerBLSPublicKey({ validator, publicKey, account }) {
+        try {
+            validateAddress(validator, 'validator');
+            validateRequired(publicKey, 'publicKey');
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'registerBLSPublicKey',
+                args: [validator, publicKey],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'registerBLSPublicKey');
+        }
+    },
+    async blsPublicKeys({ validator }) {
+        try {
+            validateAddress(validator, 'validator');
+            const result = await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'blsPublicKeys',
+                args: [validator]
+            });
+            return { publicKey: result[0], isActive: result[1] };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'blsPublicKeys');
+        }
+    },
+    // Threshold Management
+    async setDefaultThreshold({ newThreshold, account }) {
+        try {
+            validateRequired(newThreshold, 'newThreshold');
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'setDefaultThreshold',
+                args: [newThreshold],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setDefaultThreshold');
+        }
+    },
+    async setMinThreshold({ newThreshold, account }) {
+        try {
+            validateRequired(newThreshold, 'newThreshold');
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'setMinThreshold',
+                args: [newThreshold],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setMinThreshold');
+        }
+    },
+    async defaultThreshold() {
+        try {
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'defaultThreshold',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'defaultThreshold');
+        }
+    },
+    async minThreshold() {
+        try {
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'minThreshold',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'minThreshold');
+        }
+    },
+    // Proposal & Execution
+    async executeProposal({ proposalId, target, callData, requiredThreshold, proof, account }) {
+        try {
+            validateRequired(proposalId, 'proposalId');
+            validateAddress(target, 'target');
+            validateRequired(callData, 'callData');
+            validateRequired(requiredThreshold, 'requiredThreshold');
+            validateRequired(proof, 'proof');
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'executeProposal',
+                args: [proposalId, target, callData, requiredThreshold, proof],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'executeProposal');
+        }
+    },
+    async verifyAndExecute({ proposalId, operator, slashLevel, repUsers, newScores, epoch, proof, account }) {
+        try {
+            validateRequired(proposalId, 'proposalId');
+            validateAddress(operator, 'operator');
+            validateRequired(slashLevel, 'slashLevel');
+            validateRequired(repUsers, 'repUsers');
+            validateRequired(newScores, 'newScores');
+            validateRequired(epoch, 'epoch');
+            validateRequired(proof, 'proof');
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'verifyAndExecute',
+                args: [proposalId, operator, slashLevel, repUsers, newScores, epoch, proof],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'verifyAndExecute');
+        }
+    },
+    async executedProposals({ proposalId }) {
+        try {
+            validateRequired(proposalId, 'proposalId');
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'executedProposals',
+                args: [proposalId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'executedProposals');
+        }
+    },
+    async proposalNonces({ proposalId }) {
+        try {
+            validateRequired(proposalId, 'proposalId');
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'proposalNonces',
+                args: [proposalId]
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'proposalNonces');
+        }
+    },
+    // Aggregated Signatures
+    async aggregatedSignatures({ index }) {
+        try {
+            validateRequired(index, 'index');
+            const result = await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'aggregatedSignatures',
+                args: [index]
+            });
+            return {
+                aggregatedSig: result[0],
+                messageHash: result[1],
+                timestamp: result[2],
+                verified: result[3]
+            };
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'aggregatedSignatures');
+        }
+    },
+    // Config
+    async setDVTValidator({ dv, account }) {
+        try {
+            validateAddress(dv, 'dv');
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'setDVTValidator',
+                args: [dv],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setDVTValidator');
+        }
+    },
+    async setSuperPaymaster({ paymaster, account }) {
+        try {
+            validateAddress(paymaster, 'paymaster');
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'setSuperPaymaster',
+                args: [paymaster],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'setSuperPaymaster');
+        }
+    },
+    async DVT_VALIDATOR() {
+        try {
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'DVT_VALIDATOR',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'DVT_VALIDATOR');
+        }
+    },
+    async SUPERPAYMASTER() {
+        try {
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'SUPERPAYMASTER',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'SUPERPAYMASTER');
+        }
+    },
+    async REGISTRY() {
+        try {
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'REGISTRY',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'REGISTRY');
+        }
+    },
+    async MAX_VALIDATORS() {
+        try {
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'MAX_VALIDATORS',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'MAX_VALIDATORS');
+        }
+    },
+    async owner() {
+        try {
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'owner',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'owner');
+        }
+    },
+    async transferOwnership({ newOwner, account }) {
+        try {
+            validateAddress(newOwner, 'newOwner');
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'transferOwnership',
+                args: [newOwner],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'transferOwnership');
+        }
+    },
+    async renounceOwnership({ account }) {
+        try {
+            return await client.writeContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'renounceOwnership',
+                args: [],
+                account: account,
+                chain: client.chain
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'renounceOwnership');
+        }
+    },
+    async version() {
+        try {
+            return await client.readContract({
+                address,
+                abi: BLSAggregatorABI,
+                functionName: 'version',
+                args: []
+            });
+        }
+        catch (error) {
+            throw AAStarError.fromViemError(error, 'version');
+        }
     }
 });

package/dist/actions/dvt.d.ts

@@ -1,20 +1,17 @@
 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[];
@@ -22,9 +19,40 @@ export type DVTActions = {
         proof: Hex;
         account?: Account | Address;
     }) => Promise<Hash>;
+    markProposalExecuted: (args: {
+        id: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    proposals: (args: {
+        proposalId: bigint;
+    }) => Promise<{
+        operator: Address;
+        slashLevel: number;
+        reason: string;
+        executed: boolean;
+    }>;
+    nextProposalId: () => Promise<bigint>;
     isValidator: (args: {
-        address: Address;
         user: Address;
     }) => Promise<boolean>;
+    addValidator: (args: {
+        v: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setBLSAggregator: (args: {
+        aggregator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    BLS_AGGREGATOR: () => Promise<Address>;
+    REGISTRY: () => 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 declare const dvtActions: () => (client: PublicClient | WalletClient) => DVTActions;
+export declare const dvtActions: (address: Address) => (client: PublicClient | WalletClient) => DVTActions;