@hsuite/smart-engines-cli 1.0.0

package/dist/libs/multi-chain-core/src/dao/dao-proposal.service.js

@@ -0,0 +1,829 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var DaoProposalService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaoProposalService = void 0;
+const crypto = __importStar(require("crypto"));
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const smart_engines_infrastructure_1 = require("@hsuite/smart-engines-infrastructure");
+const dao_service_1 = require("./dao.service");
+const dao_snapshot_service_1 = require("./dao-snapshot.service");
+let DaoProposalService = DaoProposalService_1 = class DaoProposalService {
+    eventBus;
+    daoService;
+    snapshotService;
+    proposalModel;
+    voteModel;
+    logger = new common_1.Logger(DaoProposalService_1.name);
+    proposalCheckInterval;
+    constructor(eventBus, daoService, snapshotService, proposalModel, voteModel) {
+        this.eventBus = eventBus;
+        this.daoService = daoService;
+        this.snapshotService = snapshotService;
+        this.proposalModel = proposalModel;
+        this.voteModel = voteModel;
+        this.logger.log('DaoProposalService initialized');
+    }
+    async onModuleInit() {
+        this.proposalCheckInterval = setInterval(() => this.processExpiredProposals(), 60_000);
+        this.logger.log('DAO Proposal scheduler started (60s interval)');
+    }
+    onModuleDestroy() {
+        if (this.proposalCheckInterval) {
+            clearInterval(this.proposalCheckInterval);
+        }
+    }
+    async createProposal(daoId, request) {
+        this.logger.log(`Creating proposal in DAO ${daoId}: ${request.title}`);
+        const dao = await this.daoService?.getDao(daoId);
+        if (!dao) {
+            throw new Error(`DAO ${daoId} not found`);
+        }
+        if (dao.status !== 'active') {
+            throw new Error(`DAO ${daoId} is not active (status: ${dao.status})`);
+        }
+        const isMember = await this.daoService?.isMember(daoId, request.proposer);
+        if (!isMember) {
+            throw new Error(`Address ${request.proposer} is not an active member of DAO ${daoId}`);
+        }
+        await this.validateMaxActiveProposals(daoId, dao.votingRules.maxActiveProposals);
+        const proposalId = this.generateProposalId(daoId);
+        const snapshot = await this.snapshotService?.generateVotingSnapshot(daoId, proposalId);
+        const snapshotId = snapshot?.snapshotId ?? `snapshot-${proposalId}`;
+        const totalVotingPower = snapshot?.totalVotingPower ?? '0';
+        const votingOptions = request.votingOptions?.length
+            ? request.votingOptions
+            : [
+                { id: 'for', label: 'For' },
+                { id: 'against', label: 'Against' },
+                { id: 'abstain', label: 'Abstain' },
+            ];
+        const now = new Date();
+        const votingPeriodMs = dao.votingRules.votingPeriodMs;
+        const votingStartsAt = now;
+        const votingEndsAt = new Date(now.getTime() + votingPeriodMs);
+        const tally = {};
+        for (const option of votingOptions) {
+            tally[option.id] = '0';
+        }
+        this.validateActions(request.actions, votingOptions);
+        const config = {
+            proposalId,
+            daoId,
+            type: request.type,
+            title: request.title,
+            description: request.description,
+            content: request.content,
+            proposer: request.proposer,
+            status: 'active',
+            votingOptions,
+            votingPeriodMs,
+            votingStartsAt,
+            votingEndsAt,
+            snapshotId,
+            actions: request.actions,
+            tally,
+            quorumReached: false,
+            totalVotingPower,
+            createdAt: now,
+        };
+        if (this.proposalModel) {
+            await this.proposalModel.create(config);
+        }
+        await this.eventBus.publishEvent('dao', 'dao.proposal.created', {
+            proposalId,
+            daoId,
+            title: request.title,
+            proposer: request.proposer,
+            votingEndsAt,
+            timestamp: now,
+        });
+        this.logger.log(`Proposal ${proposalId} created in DAO ${daoId}`);
+        return config;
+    }
+    async castVote(proposalId, request) {
+        const proposal = await this.loadProposal(proposalId);
+        if (!proposal) {
+            throw new Error(`Proposal ${proposalId} not found`);
+        }
+        if (proposal.status !== 'active') {
+            throw new Error(`Proposal ${proposalId} is not active (status: ${proposal.status})`);
+        }
+        const now = new Date();
+        if (now < proposal.votingStartsAt || now > proposal.votingEndsAt) {
+            throw new Error(`Voting period for proposal ${proposalId} is not open`);
+        }
+        const validChoices = proposal.votingOptions.map((o) => o.id);
+        if (!validChoices.includes(request.choice)) {
+            throw new Error(`Invalid choice '${request.choice}'. Valid options: ${validChoices.join(', ')}`);
+        }
+        const weight = await this.snapshotService?.getVotingPower(proposal.snapshotId, request.voter) ?? '0';
+        const existingVote = await this.findExistingVote(proposalId, request.voter);
+        const dao = await this.daoService?.getDao(proposal.daoId);
+        const allowVoteChange = dao?.votingRules.allowVoteChange ?? false;
+        if (existingVote && !allowVoteChange) {
+            throw new Error(`Voter ${request.voter} has already voted on proposal ${proposalId} and vote changes are not allowed`);
+        }
+        if (existingVote && allowVoteChange) {
+            await this.updateTally(proposalId, existingVote.choice, `-${existingVote.weight}`);
+        }
+        const vote = {
+            proposalId,
+            daoId: proposal.daoId,
+            voter: request.voter,
+            choice: request.choice,
+            weight,
+            comment: request.comment,
+            chain: request.chain,
+            delegatedFrom: request.delegatedFrom,
+            timestamp: now,
+        };
+        if (this.voteModel) {
+            await this.voteModel.findOneAndUpdate({ proposalId, voter: request.voter }, { $set: vote }, { upsert: true, new: true });
+        }
+        await this.updateTally(proposalId, request.choice, weight);
+        await this.eventBus.publishEvent('dao', 'dao.vote.cast', {
+            proposalId,
+            daoId: proposal.daoId,
+            voter: request.voter,
+            choice: request.choice,
+            weight,
+            timestamp: now,
+        });
+        this.logger.log(`Vote cast on proposal ${proposalId} by ${request.voter}: ${request.choice} (weight: ${weight})`);
+        return vote;
+    }
+    async tallyVotes(proposalId) {
+        const proposal = await this.loadProposal(proposalId);
+        if (!proposal) {
+            throw new Error(`Proposal ${proposalId} not found`);
+        }
+        const dao = await this.daoService?.getDao(proposal.daoId);
+        const quorumPercent = dao?.votingRules.quorumPercent ?? 0;
+        const approvalThresholdPercent = dao?.votingRules.approvalThresholdPercent ?? 50;
+        const tally = await this.aggregateVotes(proposalId);
+        const totalVotingPower = BigInt(proposal.totalVotingPower || '0');
+        let totalVotesCast = BigInt(0);
+        for (const weight of Object.values(tally)) {
+            totalVotesCast += BigInt(weight);
+        }
+        const quorumReached = totalVotingPower > BigInt(0)
+            ? (totalVotesCast * BigInt(100)) / totalVotingPower >= BigInt(quorumPercent)
+            : false;
+        let totalNonAbstainWeight = BigInt(0);
+        let winningChoice = '';
+        let winningWeight = BigInt(0);
+        for (const [choice, weight] of Object.entries(tally)) {
+            if (choice === 'abstain')
+                continue;
+            const w = BigInt(weight);
+            totalNonAbstainWeight += w;
+            if (w > winningWeight) {
+                winningWeight = w;
+                winningChoice = choice;
+            }
+        }
+        const passed = quorumReached
+            && totalNonAbstainWeight > BigInt(0)
+            && (winningWeight * BigInt(100)) / totalNonAbstainWeight >= BigInt(approvalThresholdPercent)
+            && winningChoice === 'for';
+        const newStatus = passed
+            ? 'passed'
+            : quorumReached
+                ? 'failed'
+                : 'expired';
+        const passedAt = passed ? new Date() : undefined;
+        if (this.proposalModel) {
+            const updateFields = { status: newStatus, tally, quorumReached };
+            if (passed && winningChoice) {
+                updateFields.winningOptionId = winningChoice;
+            }
+            if (passedAt) {
+                updateFields.passedAt = passedAt;
+            }
+            await this.proposalModel.updateOne({ proposalId }, { $set: updateFields });
+        }
+        await this.eventBus.publishEvent('dao', 'dao.proposal.tallied', {
+            proposalId,
+            daoId: proposal.daoId,
+            tally,
+            quorumReached,
+            passed,
+            newStatus,
+            timestamp: new Date(),
+        });
+        this.logger.log(`Proposal ${proposalId} tallied: status=${newStatus}, quorum=${quorumReached}, passed=${passed}`);
+        if (passed) {
+            const dao = await this.daoService?.getDao(proposal.daoId);
+            const executionDelayMs = dao?.votingRules.executionDelayMs ?? 0;
+            if (executionDelayMs === 0) {
+                this.logger.log(`Proposal ${proposalId} passed with no execution delay — executing immediately via TSS`);
+                await this.executeProposal(proposalId);
+            }
+            else {
+                this.logger.log(`Proposal ${proposalId} passed — execution scheduled after ${executionDelayMs}ms delay`);
+            }
+        }
+        return { tally, quorumReached, passed, newStatus };
+    }
+    async executeProposal(proposalId) {
+        const proposal = await this.loadProposal(proposalId);
+        if (!proposal) {
+            return { success: false, error: `Proposal ${proposalId} not found` };
+        }
+        if (proposal.status !== 'passed') {
+            return { success: false, error: `Proposal ${proposalId} has not passed (status: ${proposal.status})` };
+        }
+        const dao = await this.daoService?.getDao(proposal.daoId);
+        const executionDelayMs = dao?.votingRules.executionDelayMs ?? 0;
+        if (executionDelayMs > 0) {
+            const tallyTime = proposal.votingEndsAt.getTime();
+            const now = Date.now();
+            if (now - tallyTime < executionDelayMs) {
+                const remainingMs = executionDelayMs - (now - tallyTime);
+                return { success: false, error: `Execution delay not met. ${remainingMs}ms remaining.` };
+            }
+        }
+        if (proposal.executionResult?.success === false && proposal.executionResult?.error === 'vetoed') {
+            return { success: false, error: 'Proposal has been vetoed by the veto council' };
+        }
+        try {
+            const transactionIds = [];
+            for (const action of proposal.actions) {
+                await this.eventBus.publishEvent('dao', 'dao.proposal.execute-action', {
+                    proposalId,
+                    daoId: proposal.daoId,
+                    action,
+                    timestamp: new Date(),
+                });
+                transactionIds.push(`action-${action.type}-${Date.now()}`);
+            }
+            const executedAt = new Date();
+            const executionResult = { success: true, transactionIds };
+            if (this.proposalModel) {
+                await this.proposalModel.updateOne({ proposalId }, { $set: { status: 'executed', executedAt, executionResult } });
+            }
+            await this.eventBus.publishEvent('dao', 'dao.proposal.executed', {
+                proposalId,
+                daoId: proposal.daoId,
+                transactionIds,
+                executedAt,
+                timestamp: new Date(),
+            });
+            this.logger.log(`Proposal ${proposalId} executed with ${transactionIds.length} actions`);
+            return { success: true, transactionIds };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Proposal ${proposalId} execution failed: ${errorMessage}`);
+            return { success: false, error: errorMessage };
+        }
+    }
+    async getProposal(proposalId) {
+        return this.loadProposal(proposalId);
+    }
+    async listProposals(daoId, filters) {
+        if (!this.proposalModel) {
+            return [];
+        }
+        const query = { daoId };
+        if (filters?.status) {
+            query.status = filters.status;
+        }
+        if (filters?.proposer) {
+            query.proposer = filters.proposer;
+        }
+        const docs = await this.proposalModel.find(query).exec();
+        return docs.map((doc) => this.toProposalConfig(doc));
+    }
+    async getVotes(proposalId, options) {
+        if (!this.voteModel) {
+            return [];
+        }
+        const limit = options?.limit ?? 50;
+        const offset = options?.offset ?? 0;
+        const docs = await this.voteModel
+            .find({ proposalId })
+            .skip(offset)
+            .limit(limit)
+            .exec();
+        return docs.map((doc) => this.toVote(doc));
+    }
+    async getResults(proposalId) {
+        const proposal = await this.loadProposal(proposalId);
+        if (!proposal) {
+            throw new Error(`Proposal ${proposalId} not found`);
+        }
+        const tally = await this.aggregateVotes(proposalId);
+        const dao = await this.daoService?.getDao(proposal.daoId);
+        const quorumPercent = dao?.votingRules.quorumPercent ?? 0;
+        const approvalThresholdPercent = dao?.votingRules.approvalThresholdPercent ?? 50;
+        const totalVotingPower = BigInt(proposal.totalVotingPower || '0');
+        let totalVotesCast = BigInt(0);
+        for (const weight of Object.values(tally)) {
+            totalVotesCast += BigInt(weight);
+        }
+        const quorumReached = totalVotingPower > BigInt(0)
+            ? (totalVotesCast * BigInt(100)) / totalVotingPower >= BigInt(quorumPercent)
+            : false;
+        let totalNonAbstainWeight = BigInt(0);
+        let winningWeight = BigInt(0);
+        let winningChoice = '';
+        for (const [choice, weight] of Object.entries(tally)) {
+            if (choice === 'abstain')
+                continue;
+            const w = BigInt(weight);
+            totalNonAbstainWeight += w;
+            if (w > winningWeight) {
+                winningWeight = w;
+                winningChoice = choice;
+            }
+        }
+        const passed = quorumReached
+            && totalNonAbstainWeight > BigInt(0)
+            && (winningWeight * BigInt(100)) / totalNonAbstainWeight >= BigInt(approvalThresholdPercent)
+            && winningChoice === 'for';
+        return { tally, quorumReached, passed };
+    }
+    async prepareProposal(daoId, request) {
+        this.logger.log(`Preparing proposal in DAO ${daoId}: ${request.title}`);
+        const dao = await this.daoService?.getDao(daoId);
+        if (!dao) {
+            throw new Error(`DAO ${daoId} not found`);
+        }
+        if (dao.status !== 'active') {
+            throw new Error(`DAO ${daoId} is not active (status: ${dao.status})`);
+        }
+        const isMember = await this.daoService?.isMember(daoId, request.proposer);
+        if (!isMember) {
+            throw new Error(`Address ${request.proposer} is not an active member of DAO ${daoId}`);
+        }
+        await this.validateMaxActiveProposals(daoId, dao.votingRules.maxActiveProposals);
+        const proposalId = this.generateProposalId(daoId);
+        const votingOptions = request.votingOptions?.length
+            ? request.votingOptions
+            : [
+                { id: 'for', label: 'For' },
+                { id: 'against', label: 'Against' },
+                { id: 'abstain', label: 'Abstain' },
+            ];
+        const now = new Date();
+        const votingPeriodMs = dao.votingRules.votingPeriodMs;
+        const votingStartsAt = now;
+        const votingEndsAt = new Date(now.getTime() + votingPeriodMs);
+        const tally = {};
+        for (const option of votingOptions) {
+            tally[option.id] = '0';
+        }
+        this.validateActions(request.actions, votingOptions);
+        const message = {
+            proposalId,
+            daoId,
+            type: request.type,
+            title: request.title,
+            description: request.description,
+            content: request.content,
+            proposer: request.proposer,
+            votingOptions,
+            actions: request.actions,
+            votingStartsAt: votingStartsAt.toISOString(),
+            votingEndsAt: votingEndsAt.toISOString(),
+        };
+        const config = {
+            proposalId,
+            daoId,
+            type: request.type,
+            title: request.title,
+            description: request.description,
+            content: request.content,
+            proposer: request.proposer,
+            status: 'awaiting_signature',
+            votingOptions,
+            votingPeriodMs,
+            votingStartsAt,
+            votingEndsAt,
+            snapshotId: '',
+            actions: request.actions,
+            tally,
+            quorumReached: false,
+            totalVotingPower: '0',
+            preparedMessage: {
+                message,
+                createdAt: now,
+            },
+            createdAt: now,
+        };
+        if (this.proposalModel) {
+            await this.proposalModel.create(config);
+        }
+        this.logger.log(`Proposal ${proposalId} prepared (awaiting signature)`);
+        return config;
+    }
+    async submitSignedProposal(proposalId, signature) {
+        this.logger.log(`Submitting signed proposal ${proposalId}`);
+        const proposal = await this.loadProposal(proposalId);
+        if (!proposal) {
+            throw new Error(`Proposal ${proposalId} not found`);
+        }
+        if (proposal.status !== 'awaiting_signature') {
+            throw new Error(`Proposal ${proposalId} is not awaiting signature (status: ${proposal.status})`);
+        }
+        if (!signature) {
+            throw new Error('Signature is required');
+        }
+        const snapshot = await this.snapshotService?.generateVotingSnapshot(proposal.daoId, proposalId);
+        const snapshotId = snapshot?.snapshotId ?? `snapshot-${proposalId}`;
+        const totalVotingPower = snapshot?.totalVotingPower ?? '0';
+        const now = new Date();
+        const votingEndsAt = new Date(now.getTime() + proposal.votingPeriodMs);
+        if (this.proposalModel) {
+            await this.proposalModel.updateOne({ proposalId }, {
+                $set: {
+                    status: 'active',
+                    snapshotId,
+                    totalVotingPower,
+                    votingStartsAt: now,
+                    votingEndsAt,
+                },
+                $unset: { preparedMessage: '' },
+            });
+        }
+        await this.eventBus.publishEvent('dao', 'dao.proposal.created', {
+            proposalId,
+            daoId: proposal.daoId,
+            title: proposal.title,
+            proposer: proposal.proposer,
+            votingEndsAt,
+            signature,
+            timestamp: now,
+        });
+        this.logger.log(`Proposal ${proposalId} activated after signature`);
+        return {
+            ...proposal,
+            status: 'active',
+            snapshotId,
+            totalVotingPower,
+            votingStartsAt: now,
+            votingEndsAt,
+            preparedMessage: undefined,
+        };
+    }
+    async prepareVote(proposalId, request) {
+        const proposal = await this.loadProposal(proposalId);
+        if (!proposal) {
+            throw new Error(`Proposal ${proposalId} not found`);
+        }
+        if (proposal.status !== 'active') {
+            throw new Error(`Proposal ${proposalId} is not active (status: ${proposal.status})`);
+        }
+        const now = new Date();
+        if (now < proposal.votingStartsAt || now > proposal.votingEndsAt) {
+            throw new Error(`Voting period for proposal ${proposalId} is not open`);
+        }
+        const validChoices = proposal.votingOptions.map((o) => o.id);
+        if (!validChoices.includes(request.choice)) {
+            throw new Error(`Invalid choice '${request.choice}'. Valid options: ${validChoices.join(', ')}`);
+        }
+        const weight = await this.snapshotService?.getVotingPower(proposal.snapshotId, request.voter) ?? '0';
+        const message = {
+            proposalId,
+            daoId: proposal.daoId,
+            voter: request.voter,
+            choice: request.choice,
+            weight,
+            chain: request.chain,
+            delegatedFrom: request.delegatedFrom,
+            timestamp: now.toISOString(),
+        };
+        return { proposalId, message, weight };
+    }
+    async submitSignedVote(proposalId, voteData, signature) {
+        if (!signature) {
+            throw new Error('Signature is required');
+        }
+        const proposal = await this.loadProposal(proposalId);
+        if (!proposal) {
+            throw new Error(`Proposal ${proposalId} not found`);
+        }
+        if (proposal.status !== 'active') {
+            throw new Error(`Proposal ${proposalId} is not active (status: ${proposal.status})`);
+        }
+        const now = new Date();
+        if (now < proposal.votingStartsAt || now > proposal.votingEndsAt) {
+            throw new Error(`Voting period for proposal ${proposalId} is not open`);
+        }
+        const validChoices = proposal.votingOptions.map((o) => o.id);
+        if (!validChoices.includes(voteData.choice)) {
+            throw new Error(`Invalid choice '${voteData.choice}'. Valid options: ${validChoices.join(', ')}`);
+        }
+        const weight = await this.snapshotService?.getVotingPower(proposal.snapshotId, voteData.voter) ?? '0';
+        const existingVote = await this.findExistingVote(proposalId, voteData.voter);
+        const dao = await this.daoService?.getDao(proposal.daoId);
+        const allowVoteChange = dao?.votingRules.allowVoteChange ?? false;
+        if (existingVote && !allowVoteChange) {
+            throw new Error(`Voter ${voteData.voter} has already voted on proposal ${proposalId} and vote changes are not allowed`);
+        }
+        if (existingVote && allowVoteChange) {
+            await this.updateTally(proposalId, existingVote.choice, `-${existingVote.weight}`);
+        }
+        const vote = {
+            proposalId,
+            daoId: proposal.daoId,
+            voter: voteData.voter,
+            choice: voteData.choice,
+            weight,
+            comment: voteData.comment,
+            chain: voteData.chain,
+            delegatedFrom: voteData.delegatedFrom,
+            timestamp: now,
+        };
+        if (this.voteModel) {
+            await this.voteModel.findOneAndUpdate({ proposalId, voter: voteData.voter }, { $set: vote }, { upsert: true, new: true });
+        }
+        await this.updateTally(proposalId, voteData.choice, weight);
+        await this.eventBus.publishEvent('dao', 'dao.vote.cast', {
+            proposalId,
+            daoId: proposal.daoId,
+            voter: voteData.voter,
+            choice: voteData.choice,
+            weight,
+            signature,
+            timestamp: now,
+        });
+        this.logger.log(`Signed vote submitted on proposal ${proposalId} by ${voteData.voter}: ${voteData.choice}`);
+        return vote;
+    }
+    async findByProposer(daoId, proposer) {
+        if (!this.proposalModel) {
+            return [];
+        }
+        const docs = await this.proposalModel.find({ daoId, proposer }).exec();
+        return docs.map((doc) => this.toProposalConfig(doc));
+    }
+    async findActiveProposals(daoId) {
+        if (!this.proposalModel) {
+            return [];
+        }
+        const docs = await this.proposalModel.find({ daoId, status: 'active' }).exec();
+        return docs.map((doc) => this.toProposalConfig(doc));
+    }
+    async getVoterVote(proposalId, voterAddress) {
+        return this.findExistingVote(proposalId, voterAddress);
+    }
+    async getVotesByVoter(voterAddress, options) {
+        if (!this.voteModel) {
+            return [];
+        }
+        const limit = options?.limit ?? 50;
+        const offset = options?.offset ?? 0;
+        const docs = await this.voteModel
+            .find({ voter: voterAddress })
+            .skip(offset)
+            .limit(limit)
+            .exec();
+        return docs.map((doc) => this.toVote(doc));
+    }
+    async countVotesByChoice(proposalId) {
+        if (!this.voteModel) {
+            return {};
+        }
+        const votes = await this.voteModel.find({ proposalId }).exec();
+        const counts = {};
+        for (const vote of votes) {
+            counts[vote.choice] = (counts[vote.choice] ?? 0) + 1;
+        }
+        return counts;
+    }
+    validateActions(actions, options) {
+        const validActionTypes = [
+            'dao_parameter_change', 'dao_treasury_transfer', 'dao_treasury_allocation',
+            'dao_update_details', 'dao_set_status', 'dao_add_member', 'dao_remove_member',
+            'dao_token_mint', 'dao_token_burn', 'dao_token_pause', 'dao_token_unpause',
+            'dao_token_freeze', 'dao_token_unfreeze', 'dao_token_kyc', 'dao_token_wipe',
+            'dao_token_transfer', 'dao_hbar_transfer', 'dao_custom',
+            'token.mint', 'token.burn', 'token.transfer', 'token.pause', 'token.unpause',
+            'token.freeze', 'token.unfreeze', 'token.wipe', 'token.grant_kyc', 'token.revoke_kyc',
+            'account.transfer',
+        ];
+        for (const action of actions) {
+            if (!validActionTypes.includes(action.type)) {
+                throw new Error(`Invalid action type: ${action.type}. Supported: ${validActionTypes.join(', ')}`);
+            }
+        }
+        for (const option of options) {
+            if (option.actionPayload && !validActionTypes.includes(option.actionPayload.type)) {
+                throw new Error(`Invalid action type in voting option '${option.label}': ${option.actionPayload.type}`);
+            }
+        }
+    }
+    async processExpiredProposals() {
+        if (!this.proposalModel) {
+            return;
+        }
+        try {
+            const now = new Date();
+            const expired = await this.proposalModel.find({
+                votingEndsAt: { $lt: now },
+                status: 'active',
+            }).exec();
+            for (const doc of expired) {
+                try {
+                    await this.tallyVotes(doc.proposalId);
+                    this.logger.log(`Auto-tallied expired proposal ${doc.proposalId}`);
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : 'Unknown error';
+                    this.logger.error(`Failed to auto-tally proposal ${doc.proposalId}: ${msg}`);
+                }
+            }
+            const passedProposals = await this.proposalModel.find({ status: 'passed' }).exec();
+            for (const doc of passedProposals) {
+                try {
+                    const proposal = this.toProposalConfig(doc);
+                    const dao = await this.daoService?.getDao(proposal.daoId);
+                    const executionDelayMs = dao?.votingRules.executionDelayMs ?? 0;
+                    if (executionDelayMs > 0) {
+                        const passedAt = doc.passedAt
+                            ? new Date(doc.passedAt).getTime()
+                            : proposal.votingEndsAt.getTime();
+                        if (now.getTime() >= passedAt + executionDelayMs) {
+                            this.logger.log(`Proposal ${doc.proposalId} execution delay expired — auto-executing via TSS`);
+                            await this.executeProposal(doc.proposalId);
+                        }
+                    }
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : 'Unknown error';
+                    this.logger.error(`Failed to auto-execute passed proposal ${doc.proposalId}: ${msg}`);
+                }
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`processExpiredProposals error: ${msg}`);
+        }
+    }
+    generateProposalId(daoId) {
+        return `prop-${daoId}-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+    }
+    async validateMaxActiveProposals(daoId, maxActive) {
+        if (!this.proposalModel) {
+            return;
+        }
+        const count = await this.proposalModel.countDocuments({ daoId, status: 'active' }).exec();
+        if (count >= maxActive) {
+            throw new Error(`DAO ${daoId} has reached the maximum number of active proposals (${maxActive})`);
+        }
+    }
+    async loadProposal(proposalId) {
+        if (!this.proposalModel) {
+            return null;
+        }
+        const doc = await this.proposalModel.findOne({ proposalId }).exec();
+        if (!doc) {
+            return null;
+        }
+        return this.toProposalConfig(doc);
+    }
+    async findExistingVote(proposalId, voter) {
+        if (!this.voteModel) {
+            return null;
+        }
+        const doc = await this.voteModel.findOne({ proposalId, voter }).exec();
+        if (!doc) {
+            return null;
+        }
+        return this.toVote(doc);
+    }
+    async updateTally(proposalId, choice, weight) {
+        if (!this.proposalModel) {
+            return;
+        }
+        const isNegative = weight.startsWith('-');
+        const absWeight = isNegative ? weight.slice(1) : weight;
+        const proposal = await this.proposalModel.findOne({ proposalId }).exec();
+        if (!proposal) {
+            return;
+        }
+        const currentWeight = BigInt(proposal.tally?.[choice] ?? '0');
+        const delta = isNegative ? -BigInt(absWeight) : BigInt(absWeight);
+        const newWeight = currentWeight + delta;
+        await this.proposalModel.updateOne({ proposalId }, { $set: { [`tally.${choice}`]: newWeight.toString() } });
+    }
+    async aggregateVotes(proposalId) {
+        if (!this.voteModel) {
+            return {};
+        }
+        const votes = await this.voteModel.find({ proposalId }).exec();
+        const tally = {};
+        for (const vote of votes) {
+            const current = BigInt(tally[vote.choice] ?? '0');
+            tally[vote.choice] = (current + BigInt(vote.weight)).toString();
+        }
+        return tally;
+    }
+    toProposalConfig(doc) {
+        const d = doc;
+        return {
+            proposalId: d.proposalId,
+            daoId: d.daoId,
+            type: d.type,
+            title: d.title,
+            description: d.description,
+            content: d.content,
+            proposer: d.proposer,
+            status: d.status,
+            votingOptions: d.votingOptions,
+            votingPeriodMs: d.votingPeriodMs,
+            votingStartsAt: new Date(d.votingStartsAt),
+            votingEndsAt: new Date(d.votingEndsAt),
+            executionDeadline: d.executionDeadline ? new Date(d.executionDeadline) : undefined,
+            snapshotId: d.snapshotId,
+            actions: d.actions,
+            tally: d.tally ?? {},
+            quorumReached: d.quorumReached ?? false,
+            totalVotingPower: d.totalVotingPower ?? '0',
+            hcsTopicId: d.hcsTopicId,
+            executionResult: d.executionResult,
+            passedAt: d.passedAt ? new Date(d.passedAt) : undefined,
+            createdAt: new Date(d.createdAt ?? Date.now()),
+            executedAt: d.executedAt ? new Date(d.executedAt) : undefined,
+        };
+    }
+    toVote(doc) {
+        const d = doc;
+        return {
+            proposalId: d.proposalId,
+            daoId: d.daoId,
+            voter: d.voter,
+            choice: d.choice,
+            weight: d.weight,
+            comment: d.comment,
+            chain: d.chain,
+            delegatedFrom: d.delegatedFrom,
+            timestamp: new Date(d.createdAt ?? Date.now()),
+        };
+    }
+};
+exports.DaoProposalService = DaoProposalService;
+exports.DaoProposalService = DaoProposalService = DaoProposalService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, mongoose_1.InjectModel)('DaoProposalDocument')),
+    __param(4, (0, common_1.Optional)()),
+    __param(4, (0, mongoose_1.InjectModel)('DaoVoteDocument')),
+    __metadata("design:paramtypes", [smart_engines_infrastructure_1.EventBusService,
+        dao_service_1.DaoService,
+        dao_snapshot_service_1.DaoSnapshotService,
+        mongoose_2.Model,
+        mongoose_2.Model])
+], DaoProposalService);
+//# sourceMappingURL=dao-proposal.service.js.map