天命改善提案

以太坊（Ethereum）是一个去中心化的开源的有智能合约功能的公共区块链平台.

命运神殿是一个组织,其运行着包括链上链下的一系列业务/协议,它们都由命运治理维护;

命运治理(Destiny Governance)(亦称天命治理、治理)是命运神殿的治理组织,其通过提案与投票进行治理,此提案规范了提案格式、样式、流程和限制.

DestinyTemple(DST) 与 DestinyExecutor(DSE) 是命运神殿的治理令牌,此提案确定了发行总量,令牌机制等必需值.

命运神殿账户抽象钱包协议V7(亦称命运/天命神殿V7,命运/天命代理,命运/天命钱包等)是由命运神殿发布的第一个以太坊链上的一个去中心化应用(DAPP),由一组模块化的智能合约和一个前端网页组成,
其实现了高度可定制、gas优化、安全、高效、便捷的账户抽象钱包和链上资产管理功能.

此提案是命运神殿账户抽象钱包协议V7版本部署提案,同时也是命运神殿与命运治理创世提案,旨在于创世交易前预定义天命协议与治理运行所必需的包括合约接口、ABI,预计算的部署地址在内的环境与状态值等.

从第一次以物易物开始,到黄金、白银等一般等价物,再到由国家信用背书的纸币,对于货币的尝试,人们已经历许多;

从往钱庄的第一笔存款开始,到林立的银行、金融机构,再到央行发行的数字货币,对于财富的存储,人们已尝试许多;

然而,这一切都基于对某个中心化实体的信任,而信任的代价是高昂的.

“Less Trust, More Truth” 更少的信任,更多的真相.

信用崩塌,通货膨胀,货币贬值,通过一张纸币,上位者尽情地收割属于人们的财富.

银行破产,存款冻结,理财暴雷,一串数字而已,你的资产真的属于你吗?

“Not your keys, not your coins” 不是你的私钥,不是你的硬币.

通过比特币、以太坊等加密货币,人们第一次彻底掌控了自己的资产,没有人能够在未经授权的情况下挪用不属于他的资产.

这些不受某个单一实体控制的超越主权信用背书的加密货币更可抵抗通货膨胀,货币滥发...

但是,这也将保护资产安全的责任转移到人们自己身上,一旦泄露私钥,将可能导致丢失全部的资产;同时,相比于web2,人们也更容易遭遇黑客攻击、资产被盗等不利事件.

因此部署天命神殿V7协议,可创建专属的账户抽象钱包,自定义包括多签在内的所有权管理方案,有效保护资产安全,

并通过gas优化,多重调用等节省交易费用,

高度的可定制、可组合性能够满足个人,组织的资产管理,价值存储等不同需求.

并设立治理组织以维护协议,其通过提案对所有命运神殿发布的协议/产品进行维护与治理,因此:

-明确的提案限制有助于审查提案,保护治理的安全,降低通过提案进行治理攻击的可能性;

-规范的提案格式有助于阅读和理解提案内容,以便投票;

-明确的提案流程使天命治理能够合理的预期提案状态及其维系时间,以便分配时间来达成共识;

====>创立命运神殿;

====>部署以下命运神殿账户抽象钱包协议V7版本所有合约及前端网站:

----协议----

天命神殿V7协议 由包括但不限于以下部分组成:

--合约--

-接口

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.19;

// src/factory/enum/CodeType.sol

enum CodeType {
    CreationCode,
    RuntimeCode
}

// src/factory/enum/DeployType.sol

enum DeployType {
    Create3,
    Create2,
    Create
}

// src/factory/enum/ProxyType.sol

enum ProxyType {
    DestinyTempleV7ShadowProxy,
    DestinyTempleV7BeaconProxy,
    DestinyTempleV7DiamondProxy,
    ERC1967UpgradeableBeacon,
    ERC1967UpgradeableBeaconProxy,
    ERC1967UniversalUpgradableProxy,
    ERC1167MinimalProxy,
    ERC7511MinimalProxy,
    Contract
}

// src/factory/interfaces/IDestinyFactory.sol

interface IDestinyFactory {
    event Deployed(address addr);
    event Nonce(uint256 nonce);
    event ValidatorChanged(address newValidator);
    function verifyOwnership(address verifyContract,bytes memory verifyData ) external;
    function deployAddr(DeployType deployType,ProxyType proxyType,bytes memory params,bytes32 salt,uint256 nonce) external view returns(address creator,address addr);
    function deploy(DeployType deployType,ProxyType proxyType,address callbackAddr,bytes memory initData,bytes memory params) external payable returns(address addr);
    function deployCode(ProxyType proxyType,CodeType codeType,bytes memory constructorParametersABI_Encoded) external pure returns(bytes memory code);
}

-模块:包括多个不同的模块合约,各自实现不同的功能函数,用户可以部署并使用自定义的模块合约,以下是我方部署的一部分模块合约:

-[Reserve]-
-实现执行交易功能,支持预授权交易、multicall、multidelegatecall;

-[ERC712]-
-实现ERC712交易编码;

-[ECDSA]-
-同时也是所有权验证合约,实现签名检查,支持预授权交易(v==1)和EIP1271签名(v==0);

其中合约签名格式为:

[32字节r值(合约地址)]+[32字节s值(合约签名数据在整个串联签名中的开始位置)]+[1字节v值(v==0)]

合约签名数据格式为:

[32字节签名数据长度]+[签名数据]

串联签名应当按签名者地址值从小到大排序,阁下可使用以下函数排序签名:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

struct Signature {
    uint8 v;
    bytes32 r;
    bytes32 s;
}

/// @dev divides bytes signature into `uint8 v, bytes32 r, bytes32 s`.
/// @notice Make sure to peform a bounds check for @param pos, to avoid out of bounds access on @param signatures
/// @param pos which signature to read. A prior bounds check of this parameter should be performed, to avoid out of bounds access
/// @param signatures concatenated rsv signatures
function signatureSplit(bytes memory signatures, uint256 pos)
    pure
    returns (Signature memory sign)
{
    uint8 v;
    bytes32 r;
    bytes32 s;
    // The signature format is a compact form of:
    //   {bytes32 r}{bytes32 s}{uint8 v}
    // Compact means, uint8 is not padded to 32 bytes.
    // solhint-disable-next-line no-inline-assembly
    assembly {
        let signaturePos := mul(0x41, pos)
        r := mload(add(signatures, add(signaturePos, 0x20)))
        s := mload(add(signatures, add(signaturePos, 0x40)))
        // Here we are loading the last 32 bytes, including 31 bytes
        // of 's'. There is no 'mload8' to do this.
        //
        // 'byte' is not working due to the Solidity parser, so lets
        // use the second best option, 'and'
        v := and(mload(add(signatures, add(signaturePos, 0x41))), 0xff)
    }
    sign = Signature(
        {
            v:v,
            r:r,
            s:s
        }
    );
}

contract Ecrecover {
    function ssig
    (
        bytes32 txHash,//keccak256 hash
        bytes memory signaturePacked,//ECDSA签名
        bytes memory ERC1271_signatureDataPacked //如果是合约签名(v==0)输入合约签名数据,否则输入0x
    )
        external  
        pure 
        returns(bytes memory signaturesSorted,address[] memory signers)
    {        
        uint256 num = signaturePacked.length/65;
        bytes memory ERC1271_SignatureDataPacked;
        address signer;
        Signature memory sign;
        bytes[] memory signatures = new bytes[](num);
        signers = new address[](num);

        for (uint256 i = 0; i < num;) {
            sign = signatureSplit(signaturePacked, i);

            if (sign.v == 0 || sign.v == 1) {
                signer = address(uint160(uint256(sign.r)));
            } else if (sign.v > 30) {
                signer = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", txHash)), sign.v - 4, sign.r, sign.s);
            } else {
                signer = ecrecover(txHash, sign.v, sign.r, sign.s);
            }

            signatures[i] = abi.encodePacked(sign.r,sign.s,sign.v);
            signers[i] = signer;

            unchecked { ++i; }
        }

        for (uint i = 1;i < signers.length;){
            address temp = signers[i];
            bytes memory _temp = signatures[i];
            uint j=i;

            while( (j >= 1) && (temp < signers[j-1])){
                signatures[j] = signatures[j-1];
                signers[j] =signers[j-1];
                j--;
            }
            signatures[j] = _temp;
            signers[j] =temp;

            unchecked { ++i; }
        }

        for(uint i = 0;i<signatures.length;){
            signaturesSorted = abi.encodePacked(signaturesSorted,signatures[i]);
            unchecked { ++i; }
        }

        return(abi.encodePacked(signaturesSorted,ERC1271_signatureDataPacked),signers);
    }
}

-[GuardManager]-
-实现在执行交易前后分别调用一系列用户设定的守卫合约检查交易;

-[Disable]-
-实现禁用合约功能;

合约禁用后仍然可以兑现支票;

合约禁用后发起交易只会在符合条件时自动续命,不会执行call

-[Permit]-
-实现允许用户设定的白名单地址无需所有权验证和守卫检查即可执行交易;

-由于不受守卫与签名检查,批准的调用者被允许:
在合约禁用时执行交易;
(如果已启用TimeLockGuard守卫)通过执行交易改变nonce使被TimeLockGuard要求等待执行的其他交易无效(这可以用于使黑客的攻击交易无效);
-警告:批准的调用者拥有合约的完全控制权,其可以不受限制的执行任意交易并可能阻止通过包括代理合约升级在内的手段撤销其权限,
请确保其受控并被完全信任;

在执行交易时,将轮询信标存储/代理自身存储检查调用者是否已被预先批准;

-[ModuleManager]-
-增删改查模块函数;

-[Dissociate]-
-如果在[天命周期]内代理合约无任何交易,任何人都可以申请自毁合约,
如在[等待期间]仍无任何交易,则任何人可自毁代理合约并与申请自毁者分别获得代理合约中1/26的[以太币奖励],
其余以太币将发送至[销毁地址].
-初始[天命周期]: 77天
-初始[等待期间]: [天命周期]
-初始[销毁地址]: 0地址
-初始[preDissociateTime]:1725321600(在此时间后能够发起预备解离交易并设置[finalDissociateTime]为block.timestamp+[天命周期],进入[等待期间]); -初始[finalDissociateTime]:0(在此时间后可发起解离交易销毁合约);

-[StorageAccessible]- -设置/读取任意存储槽

-[Twitter]-
-推文

注意:用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

注意:用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

-回退函数管理,实现ERC721、ERC1155、ERC777代币接收挂钩;
-实现Aave、Dydx、Uniswap闪电贷接收挂钩;

集合接口为:

// SPDX-License-Identifier: LGPL-3.0-only
// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.19;

enum IsStorage{
    No,
    Yes
}

enum StorageType {
    Struct,
    Array,
    Mapping
}

enum Operation {
    Call,
    DelegateCall
}

enum AllowFailure {
    Flase,
    True
}

struct Call {
    address target;
    Operation op;
    AllowFailure allowFailure;
    uint256 value;
    bytes callData;
}

struct DestinyTransaction{
    Call[] calls;
    bytes signatures;
    uint256 chequeNonce;
    uint256 executableTime;
}

struct Result {
    bool success;
    bytes returnData;
}

struct Storage{
    bytes32 slot;
    bytes32 value;
}

struct SlotRouter {
    StorageType storageType;
    bytes index;
}

struct Info {
    address owner;
    uint256 number;
}
interface IGenesisIntegrated {
    event Nonce(uint256 nonce);
    event TransactionExecuted(bytes32 indexed txHash);
    event Sstored(bytes32 slot, bytes32 value);  
    event Tweeted(address indexed author, uint96 time, string tweet);
    event Flash(address indexed callbacker,address indexed initiator);
    event $PreDestinyDissociate(address indexed txOriginator,address indexed caller,uint32 finalDissociateTime);
    event $DestinyDissociated(address indexed txOriginator,address indexed caller,uint32 finalDissociateTime,uint256 reward,uint256 dissociate);
    function $Dissociate_1XNPRb() external;
    function DESTINYTEMPLE_OWNERSHIP_STATE_CONTRACT_1() external view returns(address);
    function DESTINYEXECUTOR_OWNERSHIP_STATE_CONTRACT_2() external view returns(address);
    function OWNERSHIP_OWNERSHIP_STATE_CONTRACT_3() external view returns(address);
    function verifyOwnership(bytes memory verifyData) external;
    function $EncodeTxHash_1b7zSf(Call[] memory calls,uint256 nonce,uint256 deadline) external view returns (bytes32 txHash);
    function getAllGuards_vgA7g8() external view returns (address[] memory);
    function getModule_0jx1MB(bytes4 funcSelector) external view returns(address module);
    function $ExecuteTx_mzjimr(DestinyTransaction memory dtx) external payable returns (Result[] memory results);
    function slot_lB_EC_(bytes32 initialSlot,SlotRouter[] memory route) external pure returns (bytes32 slot);
    function sload_WaneqW(bytes32 slot) external view returns (bytes32 result);
    function sload_YRbAA3(bytes32[] memory slot) external view returns (bytes32[] memory result);
    function sstore_fO62sb(Storage memory _storage) external;
    function sstore_0ujRM0(Storage[] memory _storage) external;
    function $Tweet_$Xll(IsStorage isStorage,string memory tweet) external;
    function supportsInterface(bytes4 interfaceId) external pure returns (bool);
    function onERC721Received(address,address,uint256,bytes calldata) external pure returns (bytes4);
    function onERC1155Received(address operator,address from,uint256 id,uint256 value,bytes calldata data) external returns (bytes4);
    function onERC1155BatchReceived(address operator,address from,uint256[] calldata ids,uint256[] calldata values,bytes calldata data) external returns (bytes4);
    function isValidSignature(bytes memory _data,bytes memory _signature) external view returns (bytes4 magicValue);
    function isValidSignature(bytes32 _hash,bytes memory _signature) external view returns (bytes4 magicValue);
    function callFunction(address initiator, Info memory accountInfo, bytes memory data) external;
    function executeOperation(address asset,uint256 amount,uint256 premium,address initiator,bytes calldata params) external returns (bool);
    function executeOperation(address[] calldata assets,uint256[] calldata amounts,uint256[] calldata premiums,address initiator,bytes calldata params) external returns (bool);
    function uniswapV2Call(address initiator,uint256 token0Amount,uint256 token1Amount,bytes calldata params) external;
    function uniswapV3FlashCallback(uint256 fee0,uint256 fee1,bytes calldata data) external;
}

-[守卫]-
-包括多个不同的守卫合约,在通过[Reserve]模块执行交易时,各自运行不同的守卫检查,
用户可以部署并使用自定义的守卫合约,其应当实现并仅应存在(external或public的)以下接口函数:

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.19;

enum AllowFailure {
    Flase,
    True
}

enum Operation {
    Call,
    DelegateCall
}

struct Result {
    bool success;
    bytes returnData;
}

struct Call {
    address target;
    Operation op;
    AllowFailure allowFailure;
    uint256 value;
    bytes callData;
}

struct DestinyTransaction{
    Call[] calls;
    bytes signatures;
    uint256 chequeNonce;
    uint256 executableTime;
}

interface IGuard {
    function checkTransaction(DestinyTransaction memory dtx,address executor) external payable returns(bytes memory);
    function checkAfterExecution(bytes32 txHash,Result[] memory results) external payable returns(bytes memory);
}

-并在检查通过时返回

//Guard.Check.Passed
bytes constant PASSED = hex'47756172642e436865636b2e506173736564';

-在检查驳回时返回具体原因bytes值.

以下是我方部署的一部分守卫合约:

注意:用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

-执行交易时,检查是否延续模块[Dissociate]的[天命周期]. -启用此守卫时,此守卫应当是守卫数组中的第一个元素以保证自动续命.

为节省gas,7天内只会延续一次;

注意:用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

-检查合约是否被用户禁用;

注意:用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

-为守卫启用后的每笔交易增加一个[锁定期],执行交易时检查是否已到时间;
-初始[锁定期]:86400秒
-此模块在部署脚本中部署但不默认启用.

-禁用守卫的交易同样被守卫检查;

-[所有权状态合约]-
-是一个或多个状态存储合约,其存储所有权状态值,并允许所有权验证合约读取;
以下是我方部署的一部分-[所有权状态合约]-:

-[Ownership]-
-基于msg.sender的nonce存储合约,为不同的msg返回和设置单独的nonce值;

-接口

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.19;

interface IOwnership {
    function incrementNonce() external;

    function $Nonce() external view returns (uint256);

    function $Nonce(address addr) external view returns (uint256);
}

-用户可以部署自己的[所有权状态合约]

所有权状态合约应当限定仅允许终端代理合约增加nonce;

-[所有权验证合约]-
-是一个或多个模块合约,其使用所有权状态合约中的值来验证所有权;

用户可以选择所有权分配,控制方式;用户也可以自行部署所有权验证合约,其应当实现以下接口:

interface IOwnershipValidator {
    function DESTINYTEMPLE_OWNERSHIP_STATE_CONTRACT_1() external view returns(address);
    function DESTINYEXECUTOR_OWNERSHIP_STATE_CONTRACT_2() external view returns(address);
    function OWNERSHIP_OWNERSHIP_STATE_CONTRACT_3() external view returns(address);
    function verifyOwnership(bytes memory verifyData) external;
}

-其中,OWNERSHIP_STATE_CONTRACT()函数为所有权状态合约的地址,
作为不可变量存储在所有权验证合约中,默认提供3个插槽,用户可根据所有权状态合约数量提供更多或更少插槽,
命名为[所有权状态合约名称前缀]OWNERSHIP_STATE_CONTRACT[编号]
上述命名也作为[所有权状态合约]的完整名称,但使用大驼峰而不是全大写命名.

所有权验证合约应当防止验证数据跨链重复使用
所有权验证合约应当在被call和delegatecall调用时保持行为一致,
所有权验证合约具有存储和不可变量,
命运工厂将在call调用所有权验证合约时,使用其ProxiesLib.proxiesStorage().Beacon存储值与不可变量,
用户应当在自行部署的所有权验证合约中增加以下代码:

constructor(address _osca_1,address _osca_2,address _osca_3) payable {
        _OWNERSHIP_STATE_CONTRACT_1 = _osca_1;
        _OWNERSHIP_STATE_CONTRACT_2 = _osca_2;
        _OWNERSHIP_STATE_CONTRACT_3 = _osca_3;

        //不可删除,设置此合约的ProxiesLib.proxiesStorage().Beacon与ProxiesLib.proxiesStorage().Storage存储槽,
        //命运工厂会在call调用此合约进行所有权验证时使用这些值,不会在被代理合约delegatecall时使用
        assembly {
            sstore(0x3418148758b1f9e91a7d35447272be5d6ae049a7e84e742f66587a44d93e29cb,address())
            sstore(0x3418148758b1f9e91a7d35447272be5d6ae049a7e84e742f66587a44d93e29cc,address())
        }
    }

-天命代理合约:代理合约是用户终端合约,合约的状态更改始终保存在代理合约中;命运神殿提供以下三种不同的代理合约:

注意:这是天命治理控制的代理合约,用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

其将信标与存储合约地址均设置为自身;
钻石代理是指EIP-2535提出的钻石代理方案,使一个代理合约可以拥有多个实现,并能够进行函数级别的部分升级.
钻石代理中存储一个函数选择器=>模块的映射,在被call时依据函数选择器查找对应模块函数并delegatecall模块;
钻石代理可以增删改查实现的函数.
用户可以自选使用哪些模块的哪些函数并能够增删改查模块函数. 用户也能够自行部署信标合约;
升级信标会更改所有使用此信标的信标和影子代理获取的函数实现地址.

注意:这是天命治理控制的代理合约,用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

其将信标合约地址设置为信标合约并将存储合约地址设置为自身;
在被call时将函数选择器作为参数call天命信标合约以查找对应模块函数并直接delegatecall模块;
信标代理使用自身存储进行条件检查,每个代理可以拥有不同的值,并且需要初始化这些值;

注意:这是天命治理控制的代理合约,用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

其将信标与存储合约地址均设置为信标合约;
在被call时将函数选择器作为参数call天命信标合约以查找对应模块函数并直接delegatecall模块;
影子代理使用信标存储值进行所有权验证,使用同一信标的影子代理条件检查值相同,不需要初始化值;
在信标合约中拥有的权限也在影子代理中生效,更改信标合约条件检查值也将对影子代理生效;
更改影子代理条件检查值将存储在影子代理中,但在转换为信标或钻石代理后才会使用这些值;

在使用信标和影子代理时:
-用户可以自选使用哪个信标并可改查信标;
-通过将信标合约地址更改为信标合约或自身地址,能够与钻石代理相互转换;
-通过将存储合约地址更改为信标合约或自身地址,能够相互转换;

-如果信标中未找到对应模块函数,将尝试从自身存储中查找;

在执行交易时,将轮询信标存储/代理自身存储检查调用者是否已被预先批准;

此外,还有一种未使用的代理模式,即将信标合约地址设置为自身并将存储合约地址设置为信标合约;

当然,也可以将信标与存储合约地址设置为自身或信标合约以外的目标;

用户也可以将天命代理设置为其他代理合约的逻辑合约来使用;

可以嵌套delegatecall,与call和staticcall一样拥有调用栈,由于degatecall特性,无论嵌套的合约使用call或者delegatecall,存储修改仅在最外层合约生效,
即甲合约delegatecall乙合约,乙合约再delegatecall丙合约,存储修改都是修改甲合约的;
在丙合约中address(this),msg.sender是甲合约(最外层delegatecall合约)
乙合约call/staticcall丙合约,在丙合约中address(this)是丙合约,msg.sender是甲合约(最外层delegatecall合约)

-另外,此提案还将部署由将在接下来提到的九个初始执行者地址组成的[天命联合储备]使用的[所有权验证合约],[Reserve]模块合约(在部署中作为一个合约[_mod_Integrated_2]部署),及其信标[_beacon_2]与影子代理[_shadowProxy_2]合约,它们使用上述[_mod_Integrated_2].

-接口:

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.19;

enum IsStorage{
    No,
    Yes
}

enum StorageType {
    Struct,
    Array,
    Mapping
}

enum Operation {
    Call,
    DelegateCall
}

enum AllowFailure {
    Flase,
    True
}

struct Call {
    address target;
    Operation op;
    AllowFailure allowFailure;
    uint256 value;
    bytes callData;
}

struct DestinyTransaction{
    Call[] calls;
    bytes signatures;
    uint256 chequeNonce;
    uint256 executableTime;
}

struct Result {
    bool success;
    bytes returnData;
}

struct Storage{
    bytes32 slot;
    bytes32 value;
}

struct SlotRouter {
    StorageType storageType;
    bytes index;
}

struct Info {
    address owner;
    uint256 number;
}
interface IGenesisIntegrated {
    event Nonce(uint256 nonce);
    event TransactionExecuted(bytes32 indexed txHash);
    event Sstored(bytes32 slot, bytes32 value);  
    event Tweeted(address indexed author, uint96 time, string tweet);
    event Flash(address indexed callbacker,address indexed initiator);
    event $PreDestinyDissociate(address indexed txOriginator,address indexed caller,uint32 finalDissociateTime);
    event $DestinyDissociated(address indexed txOriginator,address indexed caller,uint32 finalDissociateTime,uint256 reward,uint256 dissociate);
    function OWNERSHIP_OWNERSHIP_STATE_CONTRACT_1() external view returns(address);
    function verifyOwnership(bytes memory verifyData) external;
    function $EncodeTxHash_1b7zSf(Call[] memory calls,uint256 nonce,uint256 deadline) external view returns (bytes32 txHash);
    function getModule_0jx1MB(bytes4 funcSelector) external view returns(address module);
    function $ExecuteTx_mzjimr(DestinyTransaction memory dtx) external payable returns (Result[] memory results);
    function slot_lB_EC_(bytes32 initialSlot,SlotRouter[] memory route) external pure returns (bytes32 slot);
    function sload_WaneqW(bytes32 slot) external view returns (bytes32 result);
    function sload_YRbAA3(bytes32[] memory slot) external view returns (bytes32[] memory result);
    function sstore_fO62sb(Storage memory _storage) external;
    function sstore_0ujRM0(Storage[] memory _storage) external;
    function $Tweet_$Xll(IsStorage isStorage,string memory tweet) external;
    function supportsInterface(bytes4 interfaceId) external pure returns (bool);
    function onERC721Received(address,address,uint256,bytes calldata) external pure returns (bytes4);
    function onERC1155Received(address operator,address from,uint256 id,uint256 value,bytes calldata data) external returns (bytes4);
    function onERC1155BatchReceived(address operator,address from,uint256[] calldata ids,uint256[] calldata values,bytes calldata data) external returns (bytes4);
    function isValidSignature(bytes memory _data,bytes memory _signature) external view returns (bytes4 magicValue);
    function isValidSignature(bytes32 _hash,bytes memory _signature) external view returns (bytes4 magicValue);
    function callFunction(address initiator, Info memory accountInfo, bytes memory data) external;
    function executeOperation(address asset,uint256 amount,uint256 premium,address initiator,bytes calldata params) external returns (bool);
    function executeOperation(address[] calldata assets,uint256[] calldata amounts,uint256[] calldata premiums,address initiator,bytes calldata params) external returns (bool);
    function uniswapV2Call(address initiator,uint256 token0Amount,uint256 token1Amount,bytes calldata params) external;
    function uniswapV3FlashCallback(uint256 fee0,uint256 fee1,bytes calldata data) external;
}

注意:用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

注意:这是天命治理控制的代理合约,用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

注意:这是天命治理控制的代理合约,用户应该部署自己的代理合约并delegatecall模块和守卫合约而不是直接call调用;

--前端--

-要与在Etherscan开源的合约交互,仅需输入合约地址;
-要与未开源的合约交互,请上传此合约的ABi或接口/使用已知接口/发送原始数据;

要调用天命代理中的某个模块函数,请上传此模块函数的ABi文件或接口;阁下一般能够在模块的发布页找到;

前端提供的任何功能均能够直接调用合约进行操作而不依赖天命服务器;

====>设立命运治理(Destiny Governance)作为命运神殿的治理组织;

====>在命运治理内部设立[天命联合储备];

====>部署DestinyTemple(DST) 与 DestinyExecutor(DSE)代币合约,并作为治理代币;

----治理----

-治理通过提案和基于投票权的投票结果治理协议.

-采用ERC-20标准

-无任何机制.

-可通过销毁1枚DSE铸造7777777枚.

-至多发行147777770枚.

-至少/初始发行77777777枚.

-令牌精度为0.

-在添加流动性之前开启代币私募.

-初始/私募发行价格为0.000000012850980235 ΞETH.

-初始[DST(命运神殿)]令牌分配:

-分配 | 初始发行量占比 | 最大发行量占比(不计算DSE令牌1.07倍权重时的投票权占比)

-治理:17777777枚 | 22.85% | 12.03%

-私募:15555554~0枚 | 19.99%~0% | 10.52%~0%

-流动性:38914999~54470553枚 | 50.03%~70.03% | 26.33%~36.85%

-初始执行者:614383*9=5529447枚 | 7.1% | 3.74%

-私募部分未分配完的代币将用于添加流动性.

-私募资金将用于部署gas费,多余部分将用于添加流动性,不足部分将由dstinyTemple.eth补足差额.

-流动性将在Uniswap V4部署后添加.

-采用ERC721标准

-每个地址仅允许持有一枚,且DSE的转移与销毁需要提案通过.

-可通过销毁7777777枚DST铸造1枚.

-至多发行19枚.

-至少发行0枚.

-初始发行9枚.

-初始/恒定发行价格为7777777 DST.

-初始[DSE(命运执行者)]令牌分配: