@stabilitydao/host 0.2.1 → 0.2.2

package/out/host.js

@@ -0,0 +1,765 @@
+"use strict";
+/**
+ Host prototype.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAOAction = exports.Host = exports.UnitComponentCategory = exports.UnitStatus = exports.UnitType = exports.FundingType = exports.LifecyclePhase = exports.HOST_DESCRIPTION = void 0;
+exports.getDAOUnit = getDAOUnit;
+exports.getDAOUnitMetaData = getDAOUnitMetaData;
+const chains_1 = require("./chains");
+exports.HOST_DESCRIPTION = "A Cozy Home for DAOs";
+/**
+ Lifecycle phase represents DAO tokenomics stage.
+ */
+var LifecyclePhase;
+(function (LifecyclePhase) {
+    /** Created */
+    LifecyclePhase["DRAFT"] = "DRAFT";
+    /**
+     Initial funding. DAO project passed requirements.
+     Since SEED started a DAO become real DAO:
+     - noncustodial
+     - tokenized share holdings
+     - collective management via voting
+     */
+    LifecyclePhase["SEED"] = "SEED";
+    /** Seed was not success. Raised funds sent back to seeders. */
+    LifecyclePhase["SEED_FAILED"] = "SEED_FAILED";
+    /** Using SEED funds to launch MVP / Unit generating */
+    LifecyclePhase["DEVELOPMENT"] = "DEVELOPMENT";
+    /** TGE is funding event for token liquidity and DAO developments (optionally) */
+    LifecyclePhase["TGE"] = "TGE";
+    /** Delay before any vesting allocation started */
+    LifecyclePhase["LIVE_CLIFF"] = "LIVE_CLIFF";
+    /** Vesting period active */
+    LifecyclePhase["LIVE_VESTING"] = "LIVE_VESTING";
+    /** Vesting ended - token fully distributed */
+    LifecyclePhase["LIVE"] = "LIVE";
+})(LifecyclePhase || (exports.LifecyclePhase = LifecyclePhase = {}));
+var FundingType;
+(function (FundingType) {
+    FundingType["SEED"] = "SEED";
+    FundingType["TGE"] = "TGE";
+})(FundingType || (exports.FundingType = FundingType = {}));
+/** Supported unit types */
+var UnitType;
+(function (UnitType) {
+    /** VE-token early exit fees */
+    UnitType["PVP"] = "PVP";
+    /** Decentralized finance protocol */
+    UnitType["DEFI_PROTOCOL"] = "DEFI_PROTOCOL";
+    /** Maximum Extractable Value opportunities searcher and submitter. */
+    UnitType["MEV_SEARCHER"] = "MEV_SEARCHER";
+    /** Software as a Service business */
+    //SAAS = "SAAS",
+})(UnitType || (exports.UnitType = UnitType = {}));
+/** Unit status can be changed automatically on DAO lifecycle phase changes or manually by DAO holders */
+var UnitStatus;
+(function (UnitStatus) {
+    UnitStatus["RESEARCH"] = "RESEARCH";
+    UnitStatus["BUILDING"] = "BUILDING";
+    UnitStatus["LIVE"] = "LIVE";
+})(UnitStatus || (exports.UnitStatus = UnitStatus = {}));
+/** Supported categories of running units. */
+var UnitComponentCategory;
+(function (UnitComponentCategory) {
+    UnitComponentCategory["CHAIN_SUPPORT"] = "CHAIN_SUPPORT";
+    UnitComponentCategory["ENGINE_SUPPORT"] = "ENGINE_SUPPORT";
+    UnitComponentCategory["DEFI_STRATEGY"] = "DEFI_STRATEGY";
+    UnitComponentCategory["MEV_STRATEGY"] = "MEV_STRATEGY";
+})(UnitComponentCategory || (exports.UnitComponentCategory = UnitComponentCategory = {}));
+//export type UnitComponent = StrategyShortId | ChainName | LendingEngine;
+/**
+ Typescript implementation of the Host
+ Object of this class is Host instance deployed on a single blockchain.
+
+ @class
+ */
+class Host {
+    constructor(chainId) {
+        /** Chain block timestamp */
+        this.blockTimestamp = Math.floor(new Date().getTime() / 1000);
+        /** Local DAOs storage (in form of a mapping) */
+        this.daos = {};
+        /** Actual DAO symbols at all blockchains */
+        this.usedSymbols = {};
+        /** All emitted events */
+        this.events = [];
+        /** Governance proposals. Can be created only at initialChain of DAO. */
+        this.proposals = {};
+        /** Current user address */
+        this.from = "0x00";
+        this.settings = {
+            priceDao: 1000,
+            priceUnit: 1000,
+            priceOracle: 1000,
+            priceBridge: 1000,
+            minNameLength: 1,
+            maxNameLength: 20,
+            minSymbolLength: 1,
+            maxSymbolLength: 7,
+            minVePeriod: 14,
+            maxVePeriod: 365 * 4,
+            minPvPFee: 10,
+            maxPvPFee: 100,
+            minFundingDuration: 1,
+            maxFundingDuration: 180,
+        };
+        this.chainId = chainId;
+    }
+    static getTokensNaming(name, symbol) {
+        return {
+            seedName: `${name} SEED`,
+            seedSymbol: `seed${symbol}`,
+            tgeName: `${name} PRESALE`,
+            tgeSymbol: `sale${symbol}`,
+            tokenName: name,
+            tokenSymbol: symbol,
+            xName: `x${name}`,
+            xSymbol: `x${symbol}`,
+            daoName: `${name} DAO`,
+            daoSymbol: `${symbol}_DAO`,
+        };
+    }
+    static isLiveDAO(phase) {
+        return [
+            LifecyclePhase.LIVE_CLIFF,
+            LifecyclePhase.LIVE_VESTING,
+            LifecyclePhase.LIVE,
+        ].includes(phase);
+    }
+    /**
+     * Create new DAO
+     * @throws Error
+     */
+    createDAO(name, symbol, activity, params, funding, metaDataLocation) {
+        const dao = {
+            phase: LifecyclePhase.DRAFT,
+            name,
+            symbol,
+            activity,
+            socials: [],
+            images: {},
+            deployments: {},
+            units: [],
+            params,
+            chainSettings: {
+                bbRate: 50,
+            },
+            initialChain: chains_1.chains[this.chainId].name,
+            funding,
+            vesting: [],
+            governanceSettings: {},
+            deployer: this.from,
+            daoMetaDataLocation: metaDataLocation,
+            unitsMetaData: [],
+        };
+        this.validate(dao);
+        this.daos[dao.symbol] = dao;
+        this.usedSymbols[dao.symbol] = true;
+        this._emit("DAO created");
+        this._sendCrossChainMessage(CROSS_CHAIN_MESSAGE.NEW_DAO_SYMBOL, {
+            symbol,
+        });
+        return dao;
+    }
+    /** Add live compatible DAO */
+    addLiveDAO(dao) {
+        // todo _onlyVerifier
+        this.validate(dao);
+        this.daos[dao.symbol] = dao;
+        this.usedSymbols[dao.symbol] = true;
+        this._emit("DAO created");
+        this._sendCrossChainMessage(CROSS_CHAIN_MESSAGE.NEW_DAO_SYMBOL, {
+            symbol: dao.symbol,
+        });
+    }
+    getDAOMetaData(daoMetaData, symbol) {
+        const dao = this.getDAO(symbol);
+        if (dao.daoMetaDataLocation === "local") {
+            return daoMetaData[symbol.toLowerCase()];
+        }
+        return {};
+    }
+    /** Change lifecycle phase of a DAO */
+    changePhase(symbol) {
+        // anybody can call this
+        const dao = this.getDAO(symbol);
+        const currentTasks = this.tasks(symbol);
+        if (currentTasks.length > 0) {
+            throw new Error("SolveTasksFirst");
+        }
+        if (dao.phase === LifecyclePhase.DRAFT) {
+            const seed = dao.funding[this.getFundingIndex(symbol, FundingType.SEED)];
+            if (seed.start > this.blockTimestamp) {
+                throw new Error("WaitFundingStart");
+            }
+            // SEED can be started not later than 1 week after must start
+            // todo settings.maxSeedStartDelay
+            if (seed.start < this.blockTimestamp &&
+                this.blockTimestamp - seed.start > 7 * 86400) {
+                throw new Error("TooLateSoSetupFundingAgain");
+            }
+            /*// SEED can be started not later than 1 week before end
+            if (seed.end - this.blockTimestamp < 7 * 86400) {
+              throw new Error("TooLateSoSetupFundingAgain")
+            }*/
+            // deploy seedToken
+            this.daos[symbol].deployments[this.chainId] = {
+                seedToken: "0xProxyDeployed",
+            };
+            this.daos[symbol].phase = LifecyclePhase.SEED;
+        }
+        else if (dao.phase === LifecyclePhase.SEED) {
+            const seed = dao.funding[this.getFundingIndex(symbol, FundingType.SEED)];
+            if (seed.end > this.blockTimestamp) {
+                throw new Error("WaitFundingEnd");
+            }
+            const sucess = seed.raised >= seed.minRaise;
+            if (sucess) {
+                this.daos[symbol].phase = LifecyclePhase.DEVELOPMENT;
+            }
+            else {
+                // send all raised back to seeders
+                this.daos[symbol].phase = LifecyclePhase.SEED_FAILED;
+            }
+        }
+        else if (dao.phase === LifecyclePhase.DEVELOPMENT) {
+            const tge = dao.funding[this.getFundingIndex(symbol, FundingType.TGE)];
+            if (tge.start > this.blockTimestamp) {
+                throw new Error("WaitFundingStart");
+            }
+            // deploy tgeToken
+            this.daos[symbol].deployments[this.chainId].tgeToken =
+                "0xProxyDeployedTge";
+            this.daos[symbol].phase = LifecyclePhase.TGE;
+        }
+        else if (dao.phase === LifecyclePhase.TGE) {
+            const tge = dao.funding[this.getFundingIndex(symbol, FundingType.TGE)];
+            if (tge.end > this.blockTimestamp) {
+                throw new Error("WaitFundingEnd");
+            }
+            const success = tge.raised >= tge.minRaise;
+            if (success) {
+                // deploy token, xToken, staking, daoToken
+                this.daos[symbol].deployments[this.chainId].token = "0xProxyToken";
+                this.daos[symbol].deployments[this.chainId].xToken = "0xProxyXToken";
+                this.daos[symbol].deployments[this.chainId].staking = "0xProxyStaking";
+                this.daos[symbol].deployments[this.chainId].daoToken =
+                    "0xProxyDAOToken";
+                // todo deploy vesting contracts and allocate token
+                // todo seedToken holders became xToken holders by predefined rate
+                // todo deploy v2 liquidity from TGE funds at predefined price
+                this.daos[symbol].phase = LifecyclePhase.LIVE_CLIFF;
+            }
+            else {
+                // send all raised TGE funds back to funders
+                this.daos[symbol].phase = LifecyclePhase.DEVELOPMENT;
+            }
+        }
+        else if (dao.phase === LifecyclePhase.LIVE_CLIFF) {
+            // if any vesting started then phase changed
+            const isVestingStarted = !!dao.vesting?.filter((v) => v.start < this.blockTimestamp).length;
+            if (!isVestingStarted) {
+                throw new Error("WaitVestingStart");
+            }
+            this.daos[symbol].phase = LifecyclePhase.LIVE_VESTING;
+        }
+        else if (dao.phase === LifecyclePhase.LIVE_VESTING) {
+            // if any vesting started then phase changed
+            const isVestingEnded = !dao.vesting?.filter((v) => v.end > this.blockTimestamp).length;
+            if (!isVestingEnded) {
+                throw new Error("WaitVestingEnd");
+            }
+            this.daos[symbol].phase = LifecyclePhase.LIVE;
+        }
+        else {
+            // nothing to change
+            throw new Error("ForeverLive");
+        }
+    }
+    /** @throws Error */
+    updateImages(symbol, images) {
+        // check DAO symbol
+        const dao = this.getDAO(symbol);
+        // instant execute for DRAFT
+        if (dao.phase === LifecyclePhase.DRAFT) {
+            this._onlyOwnerOf(symbol);
+            this._updateImages(symbol, images);
+            return true;
+        }
+        // create proposal for other phases
+        return this._proposeAction(symbol, DAOAction.UPDATE_IMAGES, {
+            images,
+        });
+    }
+    /** @throws Error */
+    updateSocials(symbol, socials) {
+        // check DAO symbol
+        const dao = this.getDAO(symbol);
+        // instant execute for DRAFT
+        if (dao.phase === LifecyclePhase.DRAFT) {
+            this._onlyOwnerOf(symbol);
+            this._updateSocials(symbol, socials);
+            return true;
+        }
+        // create proposal for other phases
+        return this._proposeAction(symbol, DAOAction.UPDATE_SOCIALS, {
+            socials,
+        });
+    }
+    /** @throws Error */
+    updateUnits(symbol, units, unitsMetaData) {
+        // check DAO symbol
+        const dao = this.getDAO(symbol);
+        // instant execute for DRAFT
+        if (dao.phase === LifecyclePhase.DRAFT) {
+            this._onlyOwnerOf(symbol);
+            this._updateUnits(symbol, units, unitsMetaData);
+            return true;
+        }
+        // create proposal for other phases
+        return this._proposeAction(symbol, DAOAction.UPDATE_UNITS, {
+            units,
+            unitsMetaData,
+        });
+    }
+    /** @throws Error */
+    updateFunding(symbol, funding) {
+        // check DAO symbol
+        const dao = this.getDAO(symbol);
+        // validate payload
+        this._validateFunding(dao.phase, [funding]);
+        // instant execute for DRAFT
+        if (dao.phase === LifecyclePhase.DRAFT) {
+            this._onlyOwnerOf(symbol);
+            this._updateFunding(symbol, funding);
+            return true;
+        }
+        // create proposal for other phases
+        return this._proposeAction(symbol, DAOAction.UPDATE_FUNDING, {
+            funding,
+        });
+    }
+    _updateSocials(symbol, socials) {
+        this.daos[symbol].socials = socials;
+        this._emit(`Action ${DAOAction.UPDATE_SOCIALS}`);
+    }
+    _updateUnits(symbol, units, unitsMetaData) {
+        this.daos[symbol].units = units;
+        this.daos[symbol].unitsMetaData = unitsMetaData;
+        this._emit(`Action ${DAOAction.UPDATE_UNITS}`);
+    }
+    _updateFunding(symbol, funding) {
+        const dao = this.getDAO(symbol);
+        const fundingExist = dao.funding.filter((f) => f.type === funding.type).length === 1;
+        if (fundingExist) {
+            const fundingIndex = this.getFundingIndex(symbol, funding.type);
+            this.daos[symbol].funding[fundingIndex] = funding;
+        }
+        else {
+            this.daos[symbol].funding.push(funding);
+        }
+        this._emit(`Action ${DAOAction.UPDATE_FUNDING}`);
+    }
+    updateVesting(symbol, vestings) {
+        // check DAO symbol
+        const dao = this.getDAO(symbol);
+        // validate
+        this._validateVesting(dao.phase, vestings);
+        // instant execute for DRAFT
+        if (dao.phase === LifecyclePhase.DRAFT) {
+            this._onlyOwnerOf(symbol);
+            this._updateVesting(symbol, vestings);
+            return true;
+        }
+        // create proposal for other phases
+        return this._proposeAction(symbol, DAOAction.UPDATE_VESTING, {
+            vestings,
+        });
+    }
+    fund(symbol, amount) {
+        // todo settings.minFunding
+        const dao = this.getDAO(symbol);
+        if (dao.phase === LifecyclePhase.SEED) {
+            const seedIndex = this.getFundingIndex(symbol, FundingType.SEED);
+            const seed = dao.funding[seedIndex];
+            if (seed.raised + amount >= seed.maxRaise) {
+                throw new Error("RaiseMaxExceed");
+            }
+            // transfer amount of exchangeAsset to seedToken contract
+            this.daos[symbol].funding[seedIndex].raised += amount;
+            // mint seedToken to user
+            return;
+        }
+        if (dao.phase === LifecyclePhase.TGE) {
+            const tgeIndex = this.getFundingIndex(symbol, FundingType.TGE);
+            const tge = dao.funding[tgeIndex];
+            if (tge.raised + amount >= tge.maxRaise) {
+                throw new Error("RaiseMaxExceed");
+            }
+            // transfer amount of exchangeAsset to tgeToken contract
+            this.daos[symbol].funding[tgeIndex].raised += amount;
+            // mint tgeToken to user
+            return;
+        }
+        throw new Error("NotFundingPhase");
+    }
+    receiveVotingResults(proposalId, succeed) {
+        const proposal = this.proposals[proposalId];
+        if (!proposal) {
+            throw new Error("IncorrectProposal");
+        }
+        if (proposal.status !== VotingStatus.VOTING) {
+            throw new Error("AlreadyReceived");
+        }
+        this.proposals[proposalId].status = succeed
+            ? VotingStatus.APPROVED
+            : VotingStatus.REJECTED;
+        if (succeed) {
+            if (proposal.action === DAOAction.UPDATE_IMAGES) {
+                this._updateImages(proposal.symbol, proposal.payload.images);
+            }
+            if (proposal.action === DAOAction.UPDATE_SOCIALS) {
+                this._updateSocials(proposal.symbol, proposal.payload.socials);
+            }
+            if (proposal.action === DAOAction.UPDATE_UNITS) {
+                this._updateUnits(proposal.symbol, proposal.payload.units, proposal.payload.unitsMetaData);
+            }
+            if (proposal.action === DAOAction.UPDATE_FUNDING) {
+                this._updateFunding(proposal.symbol, proposal.payload.funding);
+            }
+            if (proposal.action === DAOAction.UPDATE_VESTING) {
+                this._updateVesting(proposal.symbol, proposal.payload.vestings);
+            }
+            // todo other actions
+        }
+    }
+    /** OFF-CHAIN only **/
+    /** @throws Error */
+    roadmap(symbol) {
+        const dao = this.getDAO(symbol);
+        const r = [];
+        let tgeRun = 0;
+        for (const funding of dao.funding) {
+            if (funding.type === FundingType.SEED) {
+                r.push({
+                    phase: LifecyclePhase.SEED,
+                    start: funding.start,
+                    end: funding.end,
+                });
+            }
+            if (funding.type === FundingType.TGE) {
+                // if SEED was done
+                if (r.length > 0) {
+                    r.push({
+                        phase: LifecyclePhase.DEVELOPMENT,
+                        start: r[0].end + 1,
+                        end: funding.start - 1,
+                    });
+                }
+                tgeRun = funding.claim || funding.end;
+                r.push({
+                    phase: LifecyclePhase.TGE,
+                    start: funding.start,
+                    end: tgeRun,
+                });
+            }
+        }
+        if (dao.vesting.length > 0) {
+            let vestingStart = this.blockTimestamp;
+            let vestingEnd = this.blockTimestamp;
+            for (const vesting of dao.vesting) {
+                if (vesting.start < vestingStart) {
+                    vestingStart = vesting.start;
+                }
+                if (vesting.end > vestingEnd) {
+                    vestingEnd = vesting.end;
+                }
+            }
+            r.push({
+                phase: LifecyclePhase.LIVE_CLIFF,
+                start: tgeRun + 1,
+                end: vestingStart - 1,
+            });
+            r.push({
+                phase: LifecyclePhase.LIVE_VESTING,
+                start: vestingStart,
+                end: vestingEnd,
+            });
+            r.push({
+                phase: LifecyclePhase.LIVE,
+                start: vestingEnd + 1,
+            });
+        }
+        return r;
+    }
+    /** @throws Error */
+    tasks(symbol) {
+        const dao = this.getDAO(symbol);
+        const r = [];
+        if (dao.phase === LifecyclePhase.DRAFT) {
+            // images
+            if (!dao.images.seedToken || !dao.images.token) {
+                r.push({
+                    name: "Need images of token and seedToken",
+                });
+            }
+            // socials
+            if (dao.socials.length < 2) {
+                r.push({
+                    name: "Need at least 2 socials",
+                });
+            }
+            // units projected
+            if (dao.units.length === 0) {
+                r.push({
+                    name: "Need at least 1 projected unit",
+                });
+            }
+        }
+        else if (dao.phase === LifecyclePhase.SEED) {
+            const seedIndex = this.getFundingIndex(symbol, FundingType.SEED);
+            if (dao.funding[seedIndex].raised < dao.funding[seedIndex].minRaise &&
+                dao.funding[seedIndex].end > this.blockTimestamp) {
+                r.push({
+                    name: "Need attract minimal seed funding",
+                });
+            }
+        }
+        else if (dao.phase === LifecyclePhase.DEVELOPMENT) {
+            // check funding
+            const tgeExist = dao.funding.filter((f) => f.type === FundingType.TGE).length === 1;
+            if (!tgeExist) {
+                r.push({
+                    name: "Need add pre-TGE funding",
+                });
+            }
+            // images
+            if (!dao.images.tgeToken || !dao.images.xToken || !dao.images.daoToken) {
+                r.push({
+                    name: "Need images of all DAO tokens",
+                });
+            }
+            // setup vesting allocations
+            if (!dao.vesting?.length) {
+                r.push({
+                    name: "Need vesting allocations",
+                });
+            }
+            if (dao.unitsMetaData?.filter((unitMetaData) => unitMetaData.status === UnitStatus.LIVE).length === 0) {
+                r.push({
+                    name: "Run revenue generating units",
+                });
+            }
+        }
+        else if (dao.phase === LifecyclePhase.TGE) {
+            const tgeIndex = this.getFundingIndex(symbol, FundingType.TGE);
+            if (dao.funding[tgeIndex].raised < dao.funding[tgeIndex].minRaise &&
+                dao.funding[tgeIndex].end > this.blockTimestamp) {
+                r.push({
+                    name: "Need attract minimal TGE funding",
+                });
+            }
+        }
+        else if (dao.phase === LifecyclePhase.LIVE_CLIFF) {
+            // establish and improve
+            // build money markets
+            // bridge to chains
+        }
+        else if (dao.phase === LifecyclePhase.LIVE_VESTING) {
+            // distribute vesting funds to leverage token
+        }
+        /*if (dao.phase === LifecyclePhase.LIVE)*/
+        // lifetime revenue generating for DAO holders (till ABSORBED proposed feature)
+        return r;
+    }
+    /** Strict on-chain validation */
+    /** @throws Error */
+    validate(dao) {
+        this._validateName(dao.name);
+        this._validateSymbol(dao.symbol);
+        if (dao.params.vePeriod < this.settings.minVePeriod ||
+            dao.params.vePeriod > this.settings.maxVePeriod) {
+            throw new Error(`VePeriod(${dao.params.vePeriod})`);
+        }
+        this._validatePvpFee(dao.params.pvpFee);
+        if (!dao.funding.length) {
+            throw new Error("NeedFunding");
+        }
+        // todo: check activity are correct
+        // todo: check funding array has unique funding types
+        // todo: check funding dates
+        // todo: check funding raise goals
+    }
+    /** @throws Error */
+    getDAO(symbol) {
+        if (this.daos[symbol]) {
+            return this.daos[symbol];
+        }
+        throw new Error("DAONotFound");
+    }
+    getDaoOwner(symbol) {
+        const dao = this.getDAO(symbol);
+        if (dao.phase === LifecyclePhase.DRAFT) {
+            return dao.deployer;
+        }
+        if ([
+            LifecyclePhase.SEED,
+            LifecyclePhase.DEVELOPMENT,
+            LifecyclePhase.TGE,
+        ].includes(dao.phase)) {
+            return dao.deployments[(0, chains_1.getChainByName)(dao.initialChain).chainId]
+                .seedToken;
+        }
+        return dao.deployments[this.chainId]?.daoToken;
+    }
+    getFundingIndex(symbol, type) {
+        const dao = this.getDAO(symbol);
+        for (let i = 0; i < dao.funding.length; i++) {
+            if (type === dao.funding[i].type) {
+                return i;
+            }
+        }
+        throw new Error("FundingNotFound");
+    }
+    warpDays(days = 7) {
+        this.blockTimestamp += days * 86400;
+    }
+    /** @throws Error */
+    _onlyOwnerOf(symbol) {
+        if (this.from != this.getDaoOwner(symbol)) {
+            throw new Error(`YouAreNotOwnerOf(${symbol})`);
+        }
+    }
+    _emit(event) {
+        this.events.push(event);
+    }
+    _validateName(name) {
+        if (name.length < this.settings.minNameLength ||
+            name.length > this.settings.maxNameLength) {
+            throw new Error(`NameLength(${name.length})`);
+        }
+    }
+    _validateSymbol(symbol) {
+        if (symbol.length < this.settings.minSymbolLength ||
+            symbol.length > this.settings.maxSymbolLength) {
+            throw new Error(`SymbolLength(${symbol.length})`);
+        }
+        if (this.usedSymbols[symbol]) {
+            throw new Error(`SymbolNotUnique(${symbol})`);
+        }
+    }
+    _validatePvpFee(pvpFee) {
+        if (pvpFee < this.settings.minPvPFee || pvpFee > this.settings.maxPvPFee) {
+            throw new Error(`PvPFee(${pvpFee})`);
+        }
+    }
+    _validateFunding(daoPhase, fundings) {
+        for (const funding of fundings) {
+            if (funding.type === FundingType.SEED &&
+                daoPhase !== LifecyclePhase.DRAFT) {
+                throw new Error("TooLateToUpdateSuchFunding");
+            }
+            if (funding.type === FundingType.TGE &&
+                ![
+                    LifecyclePhase.DRAFT,
+                    LifecyclePhase.SEED,
+                    LifecyclePhase.DEVELOPMENT,
+                ].includes(daoPhase)) {
+                throw new Error("TooLateToUpdateSuchFunding");
+            }
+            // todo check min round duration
+            // todo check max round duration
+            // todo check start date delay
+            // todo check min amount
+            // todo check max amount
+        }
+    }
+    _validateVesting(daoPhase, vestings) {
+        if ([
+            LifecyclePhase.LIVE_CLIFF,
+            LifecyclePhase.LIVE_VESTING,
+            LifecyclePhase.LIVE,
+        ].includes(daoPhase)) {
+            throw new Error("TooLateToUpdateVesting");
+        }
+        for (const vesting of vestings) {
+            // todo check vesting consistency
+        }
+    }
+    _sendCrossChainMessage(type, payload) {
+        // todo some stub
+    }
+    _proposeAction(symbol, action, payload) {
+        const dao = this.getDAO(symbol);
+        // todo check for initial chain
+        // todo get user power
+        // todo check proposalThreshold
+        // todo validate payload
+        const proposalId = Math.round(Math.random() * Math.random()).toString();
+        this.proposals[proposalId] = {
+            id: proposalId,
+            created: this.blockTimestamp,
+            action,
+            symbol,
+            payload,
+            status: VotingStatus.VOTING,
+        };
+        return proposalId;
+    }
+    _updateImages(symbol, images) {
+        this.daos[symbol].images = images;
+        this._emit(`Action ${DAOAction.UPDATE_IMAGES}`);
+    }
+    _updateVesting(symbol, vestings) {
+        this.daos[symbol].vesting = vestings;
+        this._emit(`Action ${DAOAction.UPDATE_VESTING}`);
+    }
+}
+exports.Host = Host;
+var DAOAction;
+(function (DAOAction) {
+    DAOAction[DAOAction["UPDATE_IMAGES"] = 0] = "UPDATE_IMAGES";
+    DAOAction[DAOAction["UPDATE_SOCIALS"] = 1] = "UPDATE_SOCIALS";
+    DAOAction[DAOAction["UPDATE_NAMING"] = 2] = "UPDATE_NAMING";
+    DAOAction[DAOAction["UPDATE_UNITS"] = 3] = "UPDATE_UNITS";
+    DAOAction[DAOAction["UPDATE_FUNDING"] = 4] = "UPDATE_FUNDING";
+    DAOAction[DAOAction["UPDATE_VESTING"] = 5] = "UPDATE_VESTING";
+})(DAOAction || (exports.DAOAction = DAOAction = {}));
+var VotingStatus;
+(function (VotingStatus) {
+    VotingStatus[VotingStatus["VOTING"] = 0] = "VOTING";
+    VotingStatus[VotingStatus["APPROVED"] = 1] = "APPROVED";
+    VotingStatus[VotingStatus["REJECTED"] = 2] = "REJECTED";
+})(VotingStatus || (VotingStatus = {}));
+var CROSS_CHAIN_MESSAGE;
+(function (CROSS_CHAIN_MESSAGE) {
+    CROSS_CHAIN_MESSAGE[CROSS_CHAIN_MESSAGE["NEW_DAO_SYMBOL"] = 0] = "NEW_DAO_SYMBOL";
+    CROSS_CHAIN_MESSAGE[CROSS_CHAIN_MESSAGE["DAO_RENAME_SYMBOL"] = 1] = "DAO_RENAME_SYMBOL";
+    CROSS_CHAIN_MESSAGE[CROSS_CHAIN_MESSAGE["DAO_BRIDGED"] = 2] = "DAO_BRIDGED";
+})(CROSS_CHAIN_MESSAGE || (CROSS_CHAIN_MESSAGE = {}));
+function getDAOUnit(daos, symbol, unitId) {
+    for (const dao of daos) {
+        if (dao.symbol.toLowerCase() === symbol.toLowerCase()) {
+            for (const unit of dao.units) {
+                if (unit.unitId === unitId) {
+                    return unit;
+                }
+            }
+        }
+    }
+}
+function getDAOUnitMetaData(daos, symbol, unitId) {
+    for (const dao of daos) {
+        if (dao.symbol.toLowerCase() === symbol.toLowerCase()) {
+            for (let i = 0; i < dao.units.length; i++) {
+                const unit = dao.units[i];
+                if (unit.unitId === unitId) {
+                    return dao.unitsMetaData[i];
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=host.js.map