@stabilitydao/stability 0.59.2 → 0.61.2

package/out/os.js

@@ -1,726 +0,0 @@
-"use strict";
-/**
- Stability OS MVP prototype.
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DAOAction = exports.OS = exports.UnitComponentCategory = exports.UnitStatus = exports.UnitType = exports.FundingType = exports.LifecyclePhase = exports.STABILITY_OS_DESCRIPTION = void 0;
-const chains_1 = require("./chains");
-exports.STABILITY_OS_DESCRIPTION = "Operating System of Self-developing 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 = {}));
-/**
- Typescript implementation of Stability Operating System
- Object of this class is OS instance deployed on a single blockchain.
-
- @class
- */
-class OS {
-    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) {
-        const dao = {
-            phase: LifecyclePhase.DRAFT,
-            name,
-            symbol,
-            activity,
-            socials: [],
-            images: {},
-            deployments: {},
-            units: [],
-            agents: [],
-            params,
-            tokenomics: {
-                initialChain: chains_1.chains[this.chainId].name,
-                funding,
-            },
-            deployer: this.from,
-        };
-        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,
-        });
-    }
-    /** 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.tokenomics.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.tokenomics.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.tokenomics.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.tokenomics.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.tokenomics.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.tokenomics.vesting?.filter((v) => v.end > this.blockTimestamp).length;
-            if (!isVestingEnded) {
-                throw new Error("WaitVestingEnd");
-            }
-            this.daos[symbol].phase = LifecyclePhase.LIVE;
-        }
-    }
-    /** @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,
-        });
-    }
-    _updateImages(symbol, images) {
-        this.daos[symbol].images = images;
-        this._emit(`Action ${DAOAction.UPDATE_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,
-        });
-    }
-    _updateSocials(symbol, socials) {
-        this.daos[symbol].socials = socials;
-        this._emit(`Action ${DAOAction.UPDATE_SOCIALS}`);
-    }
-    /** @throws Error */
-    updateUnits(symbol, units) {
-        // check DAO symbol
-        const dao = this.getDao(symbol);
-        // instant execute for DRAFT
-        if (dao.phase === LifecyclePhase.DRAFT) {
-            this._onlyOwnerOf(symbol);
-            this._updateUnits(symbol, units);
-            return true;
-        }
-        // create proposal for other phases
-        return this._proposeAction(symbol, DAOAction.UPDATE_UNITS, {
-            units,
-        });
-    }
-    _updateUnits(symbol, units) {
-        this.daos[symbol].units = units;
-        this._emit(`Action ${DAOAction.UPDATE_UNITS}`);
-    }
-    /** @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,
-        });
-    }
-    _updateFunding(symbol, funding) {
-        const dao = this.getDao(symbol);
-        const fundingExist = dao.tokenomics.funding.filter((f) => f.type === funding.type).length ===
-            1;
-        if (fundingExist) {
-            const fundingIndex = this.getFundingIndex(symbol, funding.type);
-            this.daos[symbol].tokenomics.funding[fundingIndex] = funding;
-        }
-        else {
-            this.daos[symbol].tokenomics.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,
-        });
-    }
-    _updateVesting(symbol, vestings) {
-        this.daos[symbol].tokenomics.vesting = vestings;
-        this._emit(`Action ${DAOAction.UPDATE_VESTING}`);
-    }
-    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.tokenomics.funding[seedIndex];
-            if (seed.raised + amount >= seed.maxRaise) {
-                throw new Error("RaiseMaxExceed");
-            }
-            // transfer amount of exchangeAsset to seedToken contract
-            this.daos[symbol].tokenomics.funding[seedIndex].raised += amount;
-            // mint seedToken to user
-            return;
-        }
-        if (dao.phase === LifecyclePhase.TGE) {
-            const tgeIndex = this.getFundingIndex(symbol, FundingType.TGE);
-            const tge = dao.tokenomics.funding[tgeIndex];
-            if (tge.raised + amount >= tge.maxRaise) {
-                throw new Error("RaiseMaxExceed");
-            }
-            // transfer amount of exchangeAsset to tgeToken contract
-            this.daos[symbol].tokenomics.funding[tgeIndex].raised += amount;
-            // mint tgeToken to user
-            return;
-        }
-        throw new Error("NotFundingPhase");
-    }
-    _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;
-    }
-    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);
-            }
-            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.tokenomics.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.tokenomics.vesting) {
-            let vestingStart = this.blockTimestamp;
-            let vestingEnd = this.blockTimestamp;
-            for (const vesting of dao.tokenomics.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.tokenomics.funding[seedIndex].raised <
-                dao.tokenomics.funding[seedIndex].minRaise &&
-                dao.tokenomics.funding[seedIndex].end > this.blockTimestamp) {
-                r.push({
-                    name: "Need attract minimal seed funding",
-                });
-            }
-        }
-        else if (dao.phase === LifecyclePhase.DEVELOPMENT) {
-            // check funding
-            const tgeExist = dao.tokenomics.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.tokenomics.vesting?.length) {
-                r.push({
-                    name: "Need vesting allocations",
-                });
-            }
-            if (dao.units.filter((u) => u.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.tokenomics.funding[tgeIndex].raised <
-                dao.tokenomics.funding[tgeIndex].minRaise &&
-                dao.tokenomics.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
-        }
-        else 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.tokenomics.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.tokenomics.initialChain).chainId].seedToken;
-        }
-        return dao.deployments[this.chainId]?.daoToken;
-    }
-    getFundingIndex(symbol, type) {
-        const dao = this.getDao(symbol);
-        for (let i = 0; i < dao.tokenomics.funding.length; i++) {
-            if (type === dao.tokenomics.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
-    }
-}
-exports.OS = OS;
-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 = {}));
-//# sourceMappingURL=os.js.map