@claritydao/midnight-agora-sdk 0.2.0 → 1.2.0

package/dist/governor-api.js

@@ -1,12 +1,11 @@
-import { GovernorPrivateStateId } from "./common-types";
-import * as utils from "./utils/index";
-import { deployContract, findDeployedContract } from "@midnight-ntwrk/midnight-js-contracts";
-import { Contract, witnesses } from "@agora-dao-midnight/contract";
-import { VoteChoice, ConfigPresets } from "./types";
-import { validateDeploymentConfig, validateProposal, validateVoteChoice, validateAddress, validatePositiveBigInt } from "./validators";
-import { InvalidParameterError } from "./errors";
-/** @internal */
-const governorContractInstance = new Contract(witnesses);
+import { sampleSigningKey } from '@midnight-ntwrk/compact-runtime';
+import { GovernorPrivateStateId, } from './common-types';
+import * as utils from './utils/index';
+import { createCircuitCallTxInterface, createCircuitMaintenanceTxInterfaces, createContractMaintenanceTxInterface, deployContract, } from '@midnight-ntwrk/midnight-js-contracts';
+import { compiledGovernorBaseContract, compiledGovernorFullContract, GOVERNOR_CIRCUIT_BUNDLES, GOVERNOR_FULL_CIRCUITS, } from '@claritydao/midnight-agora-contracts';
+import { VoteChoice, ConfigPresets } from './types';
+import { validateDeploymentConfig, validateProposal, validateVoteChoice, validateAddress, validatePositiveBigInt } from './validators';
+import { InvalidParameterError } from './errors';
 // Constants to replace magic numbers
 /** @internal */
 const MILLISECONDS_TO_SECONDS = 1000;
@@ -16,33 +15,71 @@ const INITIAL_EFFECT_ID = BigInt(0);
 const DEFAULT_BIGINT_VALUE = BigInt(0);
 /** @internal */
 const getCurrentUnixTimestamp = () => BigInt(Math.floor(Date.now() / MILLISECONDS_TO_SECONDS));
+/** @internal */
+const minimalDeployQueryError = (circuitName) => new Error(`${circuitName} is not exported in the minimal preprod deploy build. Use indexed public state or a separate query package for reads.`);
 /**
  * Provides an implementation of {@link DeployedGovernorAPI} by adapting a deployed governor
  * contract.
  */
 export class GovernorAPI {
     deployedContract;
+    baseDeployedContract;
     providers;
     logger;
     /** @internal */
-    constructor(deployedContract, providers, logger) {
+    constructor(deployedContract, baseDeployedContract, providers, logger) {
         this.deployedContract = deployedContract;
+        this.baseDeployedContract = baseDeployedContract;
         this.providers = providers;
         this.logger = logger;
-        this.deployedContractAddress =
-            deployedContract.deployTxData.public.contractAddress;
+        this.deployedContractAddress = deployedContract.deployTxData.public.contractAddress;
     }
     /**
      * Gets the address of the current deployed contract.
      */
     deployedContractAddress;
+    static withGovernorProfile(providers, profile) {
+        const profileProviders = providers.governorProfiles?.[profile];
+        if (!profileProviders) {
+            return providers;
+        }
+        return {
+            ...providers,
+            zkConfigProvider: profileProviders.zkConfigProvider,
+            proofProvider: profileProviders.proofProvider,
+        };
+    }
+    static createFullDeployedContract(providers, deployTxData, contractAddress) {
+        providers.privateStateProvider.setContractAddress(contractAddress);
+        return {
+            deployTxData,
+            callTx: createCircuitCallTxInterface(providers, compiledGovernorFullContract, contractAddress, GovernorPrivateStateId),
+            circuitMaintenanceTx: createCircuitMaintenanceTxInterfaces(providers, compiledGovernorFullContract, contractAddress),
+            contractMaintenanceTx: createContractMaintenanceTxInterface(providers, compiledGovernorFullContract, contractAddress),
+        };
+    }
+    static createBaseDeployedContract(providers, deployTxData, contractAddress) {
+        const baseProviders = GovernorAPI.withGovernorProfile(providers, 'base');
+        baseProviders.privateStateProvider.setContractAddress(contractAddress);
+        return {
+            deployTxData,
+            callTx: createCircuitCallTxInterface(baseProviders, compiledGovernorBaseContract, contractAddress, GovernorPrivateStateId),
+            circuitMaintenanceTx: createCircuitMaintenanceTxInterfaces(baseProviders, compiledGovernorBaseContract, contractAddress),
+            contractMaintenanceTx: createContractMaintenanceTxInterface(baseProviders, compiledGovernorBaseContract, contractAddress),
+        };
+    }
+    static assertGovernorCircuitId(circuitId) {
+        if (!GOVERNOR_FULL_CIRCUITS.includes(circuitId)) {
+            throw new InvalidParameterError('circuitId', `Unknown governor circuit '${circuitId}'`);
+        }
+    }
     /**
      * Creates a governance proposal.
      *
      * @param title The proposal title (max 256 characters).
      * @param description The proposal description (max 10,000 characters).
      * @param creator The creator's address (32 bytes).
-     * @param actions Array of proposal actions to execute if passed.
+     * @param action The single effect action to execute if passed.
      * @returns Transaction data and proposal ID.
      *
      * @throws {InvalidParameterError} If title, description, or creator are invalid.
@@ -54,56 +91,55 @@ export class GovernorAPI {
      *
      * @example
      * ```typescript
-     * const actions: ProposalAction[] = [{
-     *   typ: 0,
+     * const action: EffectAction = {
+     *   typ: 1,
      *   token: tokenAddress,
      *   amount: BigInt(10000),
      *   to: recipientAddress,
      *   configKey: new Uint8Array(32),
      *   configValue: new Uint8Array(32),
-     * }];
+     * };
      *
      * const { proposalId, txData } = await governorAPI.createProposal(
      *   'Fund Community Initiative',
      *   'Transfer 10,000 tokens to community wallet',
      *   creatorAddress,
-     *   actions
+     *   action
      * );
      * ```
      */
-    async createProposal(title, description, creator, actions) {
+    async createProposal(title, description, creator, action) {
         this.logger?.info(`Creating proposal: ${title}`);
         this.logger?.info(`Description: ${description}`);
         // Validate parameters
         validateProposal(title, description, creator);
-        if (!Array.isArray(actions) || actions.length === 0) {
-            throw new InvalidParameterError("actions", "must be a non-empty array of ProposalAction");
+        if (Array.isArray(action)) {
+            throw new InvalidParameterError('action', 'must be exactly one EffectAction, not an array');
+        }
+        if (!action || typeof action !== 'object') {
+            throw new InvalidParameterError('action', 'must be an EffectAction');
         }
         try {
-            // Get creator's current stake
-            const stakeInfo = await this.deployedContract.callTx.getStakeInfo(creator);
-            const stakeAmount = stakeInfo.private.result.stakedAmount;
-            this.logger?.info(`Creator stake amount: ${stakeAmount}`);
             const stakeWitness = {
                 userId: creator,
-                amount: stakeAmount,
-                nonce: utils.randomBytes(32)
+                amount: DEFAULT_BIGINT_VALUE,
+                nonce: utils.randomBytes(32),
             };
             const currentTime = getCurrentUnixTimestamp();
             this.logger?.info(`Current time: ${currentTime}`);
-            const createdProposal = await this.deployedContract.callTx.createProposalWithEffect(creator, title, description, actions, stakeWitness, currentTime, currentTime + 300n);
+            const createdProposal = await this.baseDeployedContract.callTx.createProposalWithEffect(creator, title, description, action, stakeWitness, currentTime, currentTime + 300n);
             const proposalId = createdProposal.private.result;
             this.logger?.info(`Proposal created with ID: ${proposalId}, txHash: ${createdProposal.public.txHash}`);
             this.logger?.trace({
                 transactionAdded: {
-                    circuit: "createProposalWithEffect",
+                    circuit: 'createProposalWithEffect',
                     txHash: createdProposal.public.txHash,
-                    blockHeight: createdProposal.public.blockHeight
-                }
+                    blockHeight: createdProposal.public.blockHeight,
+                },
             });
             return {
                 txData: createdProposal.public,
-                proposalId: proposalId
+                proposalId: proposalId,
             };
         }
         catch (error) {
@@ -128,7 +164,7 @@ export class GovernorAPI {
      *
      * @example
      * ```typescript
-     * import { VoteChoice } from '@agora-dao-midnight/sdk';
+     * import { VoteChoice } from '@claritydao/midnight-agora-sdk';
      *
      * await governorAPI.castVote(
      *   proposalId,
@@ -139,28 +175,24 @@ export class GovernorAPI {
      */
     async castVote(proposalId, voter, choice) {
         this.logger?.info(`Casting vote on proposal ${proposalId}`);
-        this.logger?.info(`Vote choice: ${choice === VoteChoice.For ? "For" : choice === VoteChoice.Against ? "Against" : "Abstain"}`);
+        this.logger?.info(`Vote choice: ${choice === VoteChoice.For ? 'For' : choice === VoteChoice.Against ? 'Against' : 'Abstain'}`);
         // Validate parameters
-        validatePositiveBigInt(proposalId, "proposalId");
-        validateAddress(voter, "voter");
+        validatePositiveBigInt(proposalId, 'proposalId');
+        validateAddress(voter, 'voter');
         validateVoteChoice(choice);
-        // Get voter's current stake
-        const stakeInfo = await this.deployedContract.callTx.getStakeInfo(voter);
-        const stakeAmount = stakeInfo.private.result.stakedAmount;
-        this.logger?.info(`Voter stake amount: ${stakeAmount}`);
         const stakeWitness = {
             userId: voter,
-            amount: stakeAmount,
-            nonce: utils.randomBytes(32)
+            amount: DEFAULT_BIGINT_VALUE,
+            nonce: utils.randomBytes(32),
         };
-        const tx = await this.deployedContract.callTx.castVoteWithValidation(proposalId, voter, choice, stakeWitness);
+        const tx = await this.baseDeployedContract.callTx.castVoteWithValidation(proposalId, voter, choice, stakeWitness);
         this.logger?.info(`Vote cast with txHash: ${tx.public.txHash}`);
         this.logger?.trace({
             transactionAdded: {
-                circuit: "castVoteWithValidation",
+                circuit: 'castVoteWithValidation',
                 txHash: tx.public.txHash,
-                blockHeight: tx.public.blockHeight
-            }
+                blockHeight: tx.public.blockHeight,
+            },
         });
         return tx.public;
     }
@@ -179,9 +211,9 @@ export class GovernorAPI {
             proposalId: proposalId,
             effectId: INITIAL_EFFECT_ID,
             approvalTime: getCurrentUnixTimestamp(),
-            nonce: utils.randomBytes(32)
+            nonce: utils.randomBytes(32),
         };
-        const tx = await this.deployedContract.callTx.finalizeProposalWithValidation(proposalId, proofOfGovernorApproval);
+        const tx = await this.baseDeployedContract.callTx.finalizeProposalWithValidation(proposalId, proofOfGovernorApproval);
         this.logger?.info(`Proposal finalized with txHash: ${tx.public.txHash}`);
         return tx.public;
     }
@@ -200,9 +232,9 @@ export class GovernorAPI {
             proposalId: proposalId,
             effectId: INITIAL_EFFECT_ID,
             approvalTime: getCurrentUnixTimestamp(),
-            nonce: utils.randomBytes(32)
+            nonce: utils.randomBytes(32),
         };
-        const tx = await this.deployedContract.callTx.queueProposalWithValidation(proposalId, proofOfGovernorApproval);
+        const tx = await this.baseDeployedContract.callTx.queueProposalWithValidation(proposalId, proofOfGovernorApproval);
         this.logger?.info(`Proposal queued with txHash: ${tx.public.txHash}`);
         return tx.public;
     }
@@ -219,13 +251,14 @@ export class GovernorAPI {
     async executeProposal(proposalId, effectId) {
         this.logger?.info(`Executing proposal ${proposalId}`);
         this.logger?.info(`Effect ID: ${effectId}`);
+        const executionTime = getCurrentUnixTimestamp();
         const proofOfGovernorApproval = {
             proposalId: proposalId,
             effectId: effectId,
-            approvalTime: getCurrentUnixTimestamp(),
-            nonce: utils.randomBytes(32)
+            approvalTime: executionTime,
+            nonce: utils.randomBytes(32),
         };
-        const tx = await this.deployedContract.callTx.executeQueuedProposal(proposalId, effectId, proofOfGovernorApproval);
+        const tx = await this.baseDeployedContract.callTx.executeQueuedProposal(proposalId, effectId, proofOfGovernorApproval);
         this.logger?.info(`Proposal executed with txHash: ${tx.public.txHash}`);
         return tx.public;
     }
@@ -242,9 +275,9 @@ export class GovernorAPI {
         const proofOfStake = {
             userId: userId,
             amount: amount,
-            nonce: utils.randomBytes(32)
+            nonce: utils.randomBytes(32),
         };
-        const tx = await this.deployedContract.callTx.registerStakeWithValidation(userId, amount, proofOfStake);
+        const tx = await this.baseDeployedContract.callTx.registerStakeWithValidation(userId, amount, proofOfStake, getCurrentUnixTimestamp());
         this.logger?.info(`Stake registered with txHash: ${tx.public.txHash}`);
         return tx.public;
     }
@@ -256,19 +289,8 @@ export class GovernorAPI {
      */
     async getStakeInfo(userId) {
         this.logger?.info(`Getting stake info for user`);
-        try {
-            const stakeInfo = await this.deployedContract.callTx.getStakeInfo(userId);
-            this.logger?.info({
-                message: "Stake info retrieved",
-                txHash: stakeInfo.public.txHash,
-                blockHeight: stakeInfo.public.blockHeight
-            });
-            return stakeInfo;
-        }
-        catch (error) {
-            this.logger?.error(`Error getting stake info: ${error}`);
-            throw error;
-        }
+        validateAddress(userId, 'userId');
+        throw minimalDeployQueryError('getStakeInfo');
     }
     /**
      * Gets total delegated power for a user.
@@ -278,19 +300,8 @@ export class GovernorAPI {
      */
     async getTotalDelegatedPower(userId) {
         this.logger?.info(`Getting total delegated power for user`);
-        try {
-            const result = await this.deployedContract.callTx.getTotalDelegatedPower(userId);
-            this.logger?.info({
-                message: "Total delegated power retrieved",
-                txHash: result.public.txHash,
-                blockHeight: result.public.blockHeight
-            });
-            return result;
-        }
-        catch (error) {
-            this.logger?.error(`Error getting total delegated power: ${error}`);
-            throw error;
-        }
+        validateAddress(userId, 'userId');
+        throw minimalDeployQueryError('getTotalDelegatedPower');
     }
     /**
      * Gets stake record for a user.
@@ -300,19 +311,8 @@ export class GovernorAPI {
      */
     async getStakeRecord(userId) {
         this.logger?.info(`Getting stake record for user`);
-        try {
-            const result = await this.deployedContract.callTx.getStakeRecord(userId);
-            this.logger?.info({
-                message: "Stake record retrieved",
-                txHash: result.public.txHash,
-                blockHeight: result.public.blockHeight
-            });
-            return result;
-        }
-        catch (error) {
-            this.logger?.error(`Error getting stake record: ${error}`);
-            throw error;
-        }
+        validateAddress(userId, 'userId');
+        throw minimalDeployQueryError('getStakeRecord');
     }
     /**
      * Checks if user has sufficient stake to create proposals.
@@ -321,14 +321,8 @@ export class GovernorAPI {
      * @returns Result indicating if user meets threshold.
      */
     async hasProposalThreshold(userId) {
-        try {
-            const result = await this.deployedContract.callTx.hasProposalThreshold(userId);
-            return result;
-        }
-        catch (error) {
-            this.logger?.error(`Error checking proposal threshold: ${error}`);
-            throw error;
-        }
+        validateAddress(userId, 'userId');
+        throw minimalDeployQueryError('hasProposalThreshold');
     }
     /**
      * Checks if user has voting power.
@@ -337,14 +331,8 @@ export class GovernorAPI {
      * @returns Result indicating if user has voting power.
      */
     async hasVotingPower(userId) {
-        try {
-            const result = await this.deployedContract.callTx.hasVotingPower(userId);
-            return result;
-        }
-        catch (error) {
-            this.logger?.error(`Error checking voting power: ${error}`);
-            throw error;
-        }
+        validateAddress(userId, 'userId');
+        throw minimalDeployQueryError('hasVotingPower');
     }
     /**
      * Gets proposal details by ID.
@@ -354,26 +342,9 @@ export class GovernorAPI {
      */
     async getProposalDetails(proposalId) {
         this.logger?.info(`Getting proposal details for ID: ${proposalId}`);
-        try {
-            const result = await this.deployedContract.callTx.getProposal(proposalId);
-            const loggableResult = {
-                message: "Proposal details",
-                id: result.private.result.id?.toString(),
-                status: result.private.result.status,
-                votingStartTime: result.private.result.votingStartTime?.toString(),
-                votingEndTime: result.private.result.votingEndTime?.toString(),
-                creator: result.private.result.creator,
-                votesFor: result.private.result.votesFor?.toString(),
-                votesAgainst: result.private.result.votesAgainst?.toString(),
-                effectId: result.private.result.effectId?.toString()
-            };
-            this.logger?.info(loggableResult);
-            return result.private.result;
-        }
-        catch (error) {
-            this.logger?.error(`Error getting proposal details: ${error}`);
-            throw error;
-        }
+        validatePositiveBigInt(proposalId, 'proposalId');
+        const result = await this.deployedContract.callTx.getProposal(proposalId);
+        return result.private.result;
     }
     /**
      * Gets effect details by ID.
@@ -383,23 +354,9 @@ export class GovernorAPI {
      */
     async getEffectDetails(effectId) {
         this.logger?.info(`Getting effect details for ID: ${effectId}`);
-        try {
-            const result = await this.deployedContract.callTx.getEffect(effectId);
-            const loggableResult = {
-                message: "Effect details",
-                id: result.private.result.id?.toString(),
-                proposalId: result.private.result.proposalId?.toString(),
-                status: result.private.result.status,
-                executedAt: result.private.result.executedAt?.toString(),
-                actionsCount: result.private.result.actions?.length || 0
-            };
-            this.logger?.info(loggableResult);
-            return result.private.result;
-        }
-        catch (error) {
-            this.logger?.error(`Error getting effect details: ${error}`);
-            throw error;
-        }
+        validatePositiveBigInt(effectId, 'effectId');
+        const result = await this.deployedContract.callTx.getEffect(effectId);
+        return result.private.result;
     }
     /**
      * Gets the count of active proposals.
@@ -408,19 +365,8 @@ export class GovernorAPI {
      */
     async getActiveProposalCount() {
         this.logger?.info(`Getting active proposal count`);
-        try {
-            if (!this.deployedContract?.callTx) {
-                this.logger?.warn("Governor contract or callTx is undefined");
-                return DEFAULT_BIGINT_VALUE;
-            }
-            const result = await this.deployedContract.callTx.getActiveProposalCount();
-            this.logger?.info(`Active proposals: ${result.private.result}`);
-            return result.private.result;
-        }
-        catch (error) {
-            this.logger?.warn(`Could not get active proposal count: ${error}`);
-            return DEFAULT_BIGINT_VALUE;
-        }
+        this.logger?.warn('getActiveProposalCount is not exported in the minimal preprod deploy build');
+        return DEFAULT_BIGINT_VALUE;
     }
     /**
      * Gets the count of queued proposals.
@@ -429,15 +375,8 @@ export class GovernorAPI {
      */
     async getQueuedProposalCount() {
         this.logger?.info(`Getting queued proposal count`);
-        try {
-            const result = await this.deployedContract.callTx.getQueuedProposalCount();
-            this.logger?.info(`Queued proposals: ${result.private.result}`);
-            return result.private.result;
-        }
-        catch (error) {
-            this.logger?.warn(`Could not get queued proposal count: ${error}`);
-            return DEFAULT_BIGINT_VALUE;
-        }
+        this.logger?.warn('getQueuedProposalCount is not exported in the minimal preprod deploy build');
+        return DEFAULT_BIGINT_VALUE;
     }
     /**
      * Gets vote count for a proposal.
@@ -446,14 +385,9 @@ export class GovernorAPI {
      * @returns Vote count information.
      */
     async getProposalVoteCount(proposalId) {
-        try {
-            const result = await this.deployedContract.callTx.getProposalVoteCount(proposalId);
-            return result;
-        }
-        catch (error) {
-            this.logger?.error(`Error getting proposal vote count: ${error}`);
-            throw error;
-        }
+        validatePositiveBigInt(proposalId, 'proposalId');
+        const result = await this.deployedContract.callTx.getProposalVoteCount(proposalId);
+        return result.private.result;
     }
     /**
      * Gets the governor contract status.
@@ -462,15 +396,8 @@ export class GovernorAPI {
      */
     async getGovernorStatus() {
         this.logger?.info(`Getting governor status`);
-        try {
-            const result = await this.deployedContract.callTx.getGovernorStatus();
-            this.logger?.info(`Governor status retrieved`);
-            return result.private.result;
-        }
-        catch (error) {
-            this.logger?.warn(`Could not get governor status: ${error}`);
-            return null;
-        }
+        this.logger?.warn('getGovernorStatus is not exported in the minimal preprod deploy build');
+        return null;
     }
     /**
      * Gets the current time from the contract.
@@ -478,14 +405,7 @@ export class GovernorAPI {
      * @returns Current time.
      */
     async getCurrentTime() {
-        try {
-            const result = await this.deployedContract.callTx.getCurrentTime();
-            return result;
-        }
-        catch (error) {
-            this.logger?.error(`Error getting current time: ${error}`);
-            throw error;
-        }
+        throw minimalDeployQueryError('getCurrentTime');
     }
     /**
      * Gets the current contract time as a bigint.
@@ -494,16 +414,7 @@ export class GovernorAPI {
      */
     async getCurrentContractTime() {
         this.logger?.info(`Getting current contract time`);
-        try {
-            const status = await this.deployedContract.callTx.getGovernorStatus();
-            const currentTime = status.private.result.currentTime;
-            this.logger?.info(`Current contract time: ${currentTime}`);
-            return currentTime;
-        }
-        catch (error) {
-            this.logger?.error(`Error getting current contract time: ${error}`);
-            throw error;
-        }
+        throw minimalDeployQueryError('getGovernorStatus');
     }
     /**
      * Gets the treasury balance.
@@ -520,7 +431,7 @@ export class GovernorAPI {
         try {
             const state = await this.providers.publicDataProvider.queryContractState(this.deployedContractAddress);
             if (state != null) {
-                this.logger?.info("Governor contract state found");
+                this.logger?.info('Governor contract state found');
                 // Contract exists but doesn't currently expose treasury balance in public state
                 return DEFAULT_BIGINT_VALUE;
             }
@@ -545,11 +456,54 @@ export class GovernorAPI {
      * operations and proposal lifecycles.
      */
     async updateTime(newTime) {
-        this.logger?.warn("WARNING: updateTime() is for testing only. Do not use in production!");
-        this.logger?.info(`Updating contract time to: ${newTime}`);
-        const tx = await this.deployedContract.callTx.storeTimestamp(newTime);
-        this.logger?.info(`Time updated with txHash: ${tx.public.txHash}`);
-        return tx.public;
+        validatePositiveBigInt(newTime, 'newTime');
+        throw new Error('updateTime is not supported: Governor time is derived from Midnight block time.');
+    }
+    async getInstalledGovernorCircuits(contractAddress = this.deployedContractAddress) {
+        const contractState = await this.providers.publicDataProvider.queryContractState(contractAddress);
+        if (!contractState) {
+            throw new Error(`No contract state found on chain for contract address '${contractAddress}'`);
+        }
+        return GOVERNOR_FULL_CIRCUITS.filter((circuitId) => contractState.operation(circuitId) !== undefined);
+    }
+    async getMissingGovernorCircuits(contractAddress = this.deployedContractAddress, circuitIds = GOVERNOR_FULL_CIRCUITS) {
+        const installed = new Set(await this.getInstalledGovernorCircuits(contractAddress));
+        return circuitIds.filter((circuitId) => !installed.has(circuitId));
+    }
+    async installGovernorCircuit(contractAddress, circuitId) {
+        GovernorAPI.assertGovernorCircuitId(circuitId);
+        const missing = await this.getMissingGovernorCircuits(contractAddress, [circuitId]);
+        if (missing.length === 0) {
+            return { circuitId, status: 'already-installed' };
+        }
+        const signingKey = await this.providers.privateStateProvider.getSigningKey(contractAddress);
+        if (!signingKey) {
+            throw new Error('Cannot install circuits because the maintenance signing key for this contract is missing.');
+        }
+        const verifierKey = await this.providers.zkConfigProvider.getVerifierKey(circuitId);
+        const txData = await this.deployedContract.circuitMaintenanceTx[circuitId].insertVerifierKey(verifierKey);
+        return {
+            circuitId,
+            status: 'installed',
+            txData,
+        };
+    }
+    async installGovernorCircuitBundle(contractAddress, bundle) {
+        const circuitIds = GOVERNOR_CIRCUIT_BUNDLES[bundle];
+        if (!circuitIds) {
+            throw new InvalidParameterError('bundle', `Unknown governor circuit bundle '${bundle}'`);
+        }
+        return {
+            bundle,
+            results: await this.ensureGovernorCircuits(contractAddress, circuitIds),
+        };
+    }
+    async ensureGovernorCircuits(contractAddress, circuitIds) {
+        const results = [];
+        for (const circuitId of circuitIds) {
+            results.push(await this.installGovernorCircuit(contractAddress, circuitId));
+        }
+        return results;
     }
     /**
      * Displays comprehensive governor status.
@@ -567,13 +521,15 @@ export class GovernorAPI {
             this.logger?.info(`Active proposals: ${Number(activeProposals)}`);
             this.logger?.info(`Queued proposals: ${Number(queuedProposals)}`);
             this.logger?.info(`Treasury balance: ${Number(treasuryBalance)}`);
-            this.logger?.info(`Current time: ${Number(status.currentTime)}`);
+            if (status?.currentTime != null) {
+                this.logger?.info(`Current time: ${Number(status.currentTime)}`);
+            }
             return {
                 contractAddress,
                 activeProposals,
                 queuedProposals,
                 treasuryBalance,
-                isActive: true
+                isActive: true,
             };
         }
         catch (error) {
@@ -583,7 +539,7 @@ export class GovernorAPI {
                 activeProposals: DEFAULT_BIGINT_VALUE,
                 queuedProposals: DEFAULT_BIGINT_VALUE,
                 treasuryBalance: DEFAULT_BIGINT_VALUE,
-                isActive: false
+                isActive: false,
             };
         }
     }
@@ -598,7 +554,7 @@ export class GovernorAPI {
      *
      * @example
      * ```typescript
-     * import { GovernorAPI, ConfigPresets } from '@agora-dao-midnight/sdk';
+     * import { GovernorAPI, ConfigPresets } from '@claritydao/midnight-agora-sdk';
      * import { randomBytes } from '@midnight-ntwrk/midnight-js-utils';
      *
      * const config = {
@@ -623,28 +579,29 @@ export class GovernorAPI {
      * ```
      */
     static async deploy(providers, config, logger) {
-        logger?.info("Deploying governor contract");
+        logger?.info('Deploying governor contract');
         // Validate configuration
         validateDeploymentConfig(config);
-        const args = [
-            config.governor,
-            config.token.name,
-            config.token.symbol,
-            config.token.decimals,
-            config.adminKey
-        ];
-        const deployedGovernorContract = await deployContract(providers, {
+        const baseProviders = GovernorAPI.withGovernorProfile(providers, 'base');
+        const initialPrivateState = {
+            ...(await GovernorAPI.getPrivateState(baseProviders)),
+            secretKey: config.adminKey,
+        };
+        const args = [config.governor, config.token.name, config.token.symbol, config.token.decimals, initialPrivateState.secretKey];
+        const deployedGovernorBaseContract = await deployContract(baseProviders, {
             privateStateId: GovernorPrivateStateId,
-            contract: governorContractInstance,
-            initialPrivateState: await GovernorAPI.getPrivateState(providers),
-            args
+            initialPrivateState,
+            compiledContract: compiledGovernorBaseContract,
+            args,
         });
+        const deployedGovernorContract = GovernorAPI.createFullDeployedContract(providers, deployedGovernorBaseContract.deployTxData, deployedGovernorBaseContract.deployTxData.public.contractAddress);
+        const deployedGovernorBaseCallContract = GovernorAPI.createBaseDeployedContract(providers, deployedGovernorBaseContract.deployTxData, deployedGovernorBaseContract.deployTxData.public.contractAddress);
         logger?.trace({
             contractDeployed: {
-                finalizedDeployTxData: deployedGovernorContract.deployTxData.public
-            }
+                finalizedDeployTxData: deployedGovernorContract.deployTxData.public,
+            },
         });
-        return new GovernorAPI(deployedGovernorContract, providers, logger);
+        return new GovernorAPI(deployedGovernorContract, deployedGovernorBaseCallContract, providers, logger);
     }
     /**
      * Finds an already deployed governor contract on the network, and joins it.
@@ -658,21 +615,37 @@ export class GovernorAPI {
     static async join(providers, contractAddress, logger) {
         logger?.info({
             joinContract: {
-                contractAddress
-            }
-        });
-        const deployedGovernorContract = await findDeployedContract(providers, {
-            contractAddress,
-            contract: governorContractInstance,
-            privateStateId: GovernorPrivateStateId,
-            initialPrivateState: await GovernorAPI.getPrivateState(providers)
+                contractAddress,
+            },
         });
+        providers.privateStateProvider.setContractAddress(contractAddress);
+        const [finalizedTxData, initialContractState, existingSigningKey, initialPrivateState] = await Promise.all([
+            providers.publicDataProvider.watchForDeployTxData(contractAddress),
+            providers.publicDataProvider.queryDeployContractState(contractAddress),
+            providers.privateStateProvider.getSigningKey(contractAddress),
+            GovernorAPI.getPrivateState(providers, contractAddress),
+        ]);
+        if (!initialContractState) {
+            throw new Error(`No contract deployed at contract address '${contractAddress}'`);
+        }
+        const deployedGovernorContract = GovernorAPI.createFullDeployedContract(providers, {
+            private: {
+                signingKey: existingSigningKey ?? sampleSigningKey(),
+                initialPrivateState,
+            },
+            public: {
+                ...finalizedTxData,
+                contractAddress,
+                initialContractState,
+            },
+        }, contractAddress);
+        const deployedGovernorBaseContract = GovernorAPI.createBaseDeployedContract(providers, deployedGovernorContract.deployTxData, contractAddress);
         logger?.trace({
             contractJoined: {
-                finalizedDeployTxData: deployedGovernorContract.deployTxData.public
-            }
+                finalizedDeployTxData: deployedGovernorContract.deployTxData.public,
+            },
         });
-        return new GovernorAPI(deployedGovernorContract, providers, logger);
+        return new GovernorAPI(deployedGovernorContract, deployedGovernorBaseContract, providers, logger);
     }
     /**
      * Gets or initializes the private state for the governor contract.
@@ -685,10 +658,20 @@ export class GovernorAPI {
      * if none exists. The governance config in the private state is initialized with testing defaults
      * and should be updated from the actual contract configuration after joining.
      */
-    static async getPrivateState(providers) {
-        const existingPrivateState = await providers.privateStateProvider.get(GovernorPrivateStateId);
-        if (existingPrivateState) {
-            return existingPrivateState;
+    static async getPrivateState(providers, contractAddress) {
+        if (contractAddress) {
+            providers.privateStateProvider.setContractAddress(contractAddress);
+        }
+        try {
+            const existingPrivateState = await providers.privateStateProvider.get(GovernorPrivateStateId);
+            if (existingPrivateState) {
+                return existingPrivateState;
+            }
+        }
+        catch (error) {
+            if (contractAddress) {
+                throw error;
+            }
         }
         const secretKey = utils.randomBytes(32);
         const currentTime = getCurrentUnixTimestamp();
@@ -701,16 +684,18 @@ export class GovernorAPI {
             userStake: {
                 amount: DEFAULT_BIGINT_VALUE,
                 delegatedTo: new Uint8Array(32),
-                stakedAt: currentTime
+                stakedAt: currentTime,
             },
             votingHistory: [],
             proposalHistory: [],
-            governanceConfig: defaultConfig
+            governanceConfig: defaultConfig,
         };
-        await providers.privateStateProvider.set(GovernorPrivateStateId, newPrivateState);
+        if (contractAddress) {
+            await providers.privateStateProvider.set(GovernorPrivateStateId, newPrivateState);
+        }
         return newPrivateState;
     }
 }
-export * as utils from "./utils/index";
-export * from "./common-types";
+export * as utils from './utils/index';
+export * from './common-types';
 //# sourceMappingURL=governor-api.js.map