// SPDX-FileCopyrightText: © 2023 Dai Foundation <www.daifoundation.org>
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity ^0.8.16;

import {ScriptTools} from "lib/dss-test/src/ScriptTools.sol";

import {AllocatorOracle} from "src/AllocatorOracle.sol";
import {AllocatorRoles} from "src/AllocatorRoles.sol";
import {AllocatorRegistry} from "src/AllocatorRegistry.sol";
import {AllocatorBuffer} from "src/AllocatorBuffer.sol";
import {AllocatorVault} from "src/AllocatorVault.sol";
import {Swapper} from "src/funnels/Swapper.sol";
import {DepositorUniV3} from "src/funnels/DepositorUniV3.sol";
import {VaultMinter} from "src/funnels/automation/VaultMinter.sol";
import {StableSwapper} from "src/funnels/automation/StableSwapper.sol";
import {StableDepositorUniV3} from "src/funnels/automation/StableDepositorUniV3.sol";
import {ConduitMover} from "src/funnels/automation/ConduitMover.sol";

import {AllocatorSharedInstance, AllocatorIlkInstance} from "./AllocatorInstances.sol";

library AllocatorDeploy {
    // Note: owner is assumed to be the pause proxy
    function deployShared(
        address deployer,
        address owner
    ) internal returns (AllocatorSharedInstance memory sharedInstance) {
        address _oracle = address(new AllocatorOracle());

        address _roles = address(new AllocatorRoles());
        ScriptTools.switchOwner(_roles, deployer, owner);

        address _registry = address(new AllocatorRegistry());
        ScriptTools.switchOwner(_registry, deployer, owner);

        sharedInstance.oracle = _oracle;
        sharedInstance.roles = _roles;
        sharedInstance.registry = _registry;
    }

    // Note: owner is assumed to be the pause proxy, allocator proxy will receive ownerships on init
    function deployIlk(
        address deployer,
        address owner,
        address roles,
        bytes32 ilk,
        address nstJoin,
        address uniV3Factory
    ) internal returns (AllocatorIlkInstance memory ilkInstance) {
        address _buffer = address(new AllocatorBuffer());
        ScriptTools.switchOwner(_buffer, deployer, owner);
        ilkInstance.buffer = _buffer;

        address _vault = address(
            new AllocatorVault(roles, _buffer, ilk, nstJoin)
        );
        ScriptTools.switchOwner(_vault, deployer, owner);
        ilkInstance.vault = _vault;

        address _swapper = address(new Swapper(roles, ilk, _buffer));
        ScriptTools.switchOwner(_swapper, deployer, owner);
        ilkInstance.swapper = _swapper;

        address _depositorUniV3 = address(
            new DepositorUniV3(roles, ilk, uniV3Factory, _buffer)
        );
        ScriptTools.switchOwner(_depositorUniV3, deployer, owner);
        ilkInstance.depositorUniV3 = _depositorUniV3;

        {
            address _vaultMinter = address(new VaultMinter(_vault));
            ScriptTools.switchOwner(_vaultMinter, deployer, owner);
            ilkInstance.vaultMinter = _vaultMinter;
        }

        {
            address _stableSwapper = address(new StableSwapper(_swapper));
            ScriptTools.switchOwner(_stableSwapper, deployer, owner);
            ilkInstance.stableSwapper = _stableSwapper;
        }

        {
            address _stableDepositorUniV3 = address(
                new StableDepositorUniV3(_depositorUniV3)
            );
            ScriptTools.switchOwner(_stableDepositorUniV3, deployer, owner);
            ilkInstance.stableDepositorUniV3 = _stableDepositorUniV3;
        }

        {
            address _conduitMover = address(new ConduitMover(ilk, _buffer));
            ScriptTools.switchOwner(_conduitMover, deployer, owner);
            ilkInstance.conduitMover = _conduitMover;
        }

        ilkInstance.owner = owner;
    }
}


AllocatorDeploy

// SPDX-FileCopyrightText: © 2023 Dai Foundation <www.daifoundation.org>
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

import {ScriptTools} from "lib/dss-test/src/ScriptTools.sol";
import {DssInstance} from "lib/dss-test/src/MCD.sol";
import {AllocatorSharedInstance, AllocatorIlkInstance} from "./AllocatorInstances.sol";

interface WardsLike {
    function rely(address) external;

    function deny(address) external;
}

interface IlkRegistryLike {
    function put(
        bytes32 _ilk,
        address _join,
        address _gem,
        uint256 _dec,
        uint256 _class,
        address _pip,
        address _xlip,
        string calldata _name,
        string calldata _symbol
    ) external;
}

interface RolesLike {
    function setIlkAdmin(bytes32, address) external;

    function setUserRole(bytes32, address, uint8, bool) external;

    function setRoleAction(bytes32, uint8, address, bytes4, bool) external;
}

interface RegistryLike {
    function file(bytes32, bytes32, address) external;
}

interface VaultLike {
    function ilk() external view returns (bytes32);

    function roles() external view returns (address);

    function buffer() external view returns (address);

    function vat() external view returns (address);

    function nst() external view returns (address);

    function file(bytes32, address) external;

    function draw(uint256) external;

    function wipe(uint256) external;
}

interface BufferLike {
    function approve(address, address, uint256) external;
}

interface SwapperLike {
    function roles() external view returns (address);

    function ilk() external view returns (bytes32);

    function buffer() external view returns (address);

    function swap(
        address,
        address,
        uint256,
        uint256,
        address,
        bytes calldata
    ) external returns (uint256);
}

interface DepositorUniV3Like {
    struct LiquidityParams {
        address gem0;
        address gem1;
        uint24 fee;
        int24 tickLower;
        int24 tickUpper;
        uint128 liquidity;
        uint256 amt0Desired;
        uint256 amt1Desired;
        uint256 amt0Min;
        uint256 amt1Min;
    }

    struct CollectParams {
        address gem0;
        address gem1;
        uint24 fee;
        int24 tickLower;
        int24 tickUpper;
    }

    function roles() external view returns (address);

    function ilk() external view returns (bytes32);

    function uniV3Factory() external view returns (address);

    function buffer() external view returns (address);

    function deposit(
        LiquidityParams memory
    ) external returns (uint128, uint256, uint256);

    function withdraw(
        LiquidityParams memory,
        bool
    ) external returns (uint128, uint256, uint256, uint256, uint256);

    function collect(CollectParams memory) external returns (uint256, uint256);
}

interface VaultMinterLike {
    function vault() external view returns (address);
}

interface StableSwapperLike {
    function swapper() external view returns (address);
}

interface StableDepositorUniV3Like {
    function depositor() external view returns (address);
}

interface ConduitMoverLike {
    function ilk() external view returns (bytes32);

    function buffer() external view returns (address);
}

interface KissLike {
    function kiss(address) external;
}

interface AutoLineLike {
    function setIlk(bytes32, uint256, uint256, uint256) external;
}

struct AllocatorIlkConfig {
    bytes32 ilk;
    uint256 duty;
    uint256 gap;
    uint256 maxLine;
    uint256 ttl;
    address allocatorProxy;
    uint8 facilitatorRole;
    uint8 automationRole;
    address[] facilitators;
    address[] vaultMinterKeepers;
    address[] stableSwapperKeepers;
    address[] stableDepositorUniV3Keepers;
    address[] conduitMoverKeepers;
    address[] swapTokens;
    address[] depositTokens;
    address ilkRegistry;
    address uniV3Factory;
}

function bytes32ToStr(bytes32 _bytes32) pure returns (string memory) {
    uint256 len;
    while (len < 32 && _bytes32[len] != 0) len++;
    bytes memory bytesArray = new bytes(len);
    for (uint256 i; i < len; i++) {
        bytesArray[i] = _bytes32[i];
    }
    return string(bytesArray);
}

library AllocatorInit {
    uint256 constant WAD = 10 ** 18;
    uint256 constant RAY = 10 ** 27;
    uint256 constant RAD = 10 ** 45;

    uint256 constant RATES_ONE_HUNDRED_PCT = 1000000021979553151239153027;

    function initShared(
        DssInstance memory dss,
        AllocatorSharedInstance memory sharedInstance
    ) internal {
        dss.chainlog.setAddress("ALLOCATOR_ROLES", sharedInstance.roles);
        dss.chainlog.setAddress("ALLOCATOR_REGISTRY", sharedInstance.registry);
    }

    function initIlk(
        DssInstance memory dss,
        AllocatorSharedInstance memory sharedInstance,
        AllocatorIlkInstance memory ilkInstance,
        AllocatorIlkConfig memory cfg
    ) internal {
        bytes32 ilk = cfg.ilk;

        // Sanity checks
        require(
            VaultLike(ilkInstance.vault).ilk() == ilk,
            "AllocatorInit/vault-ilk-mismatch"
        );
        require(
            VaultLike(ilkInstance.vault).roles() == sharedInstance.roles,
            "AllocatorInit/vault-roles-mismatch"
        );
        require(
            VaultLike(ilkInstance.vault).buffer() == ilkInstance.buffer,
            "AllocatorInit/vault-buffer-mismatch"
        );
        require(
            VaultLike(ilkInstance.vault).vat() == address(dss.vat),
            "AllocatorInit/vault-vat-mismatch"
        );
        // Once nstJoin is in the chainlog and adapted to dss-test should also check against it

        require(
            SwapperLike(ilkInstance.swapper).roles() == sharedInstance.roles,
            "AllocatorInit/swapper-roles-mismatch"
        );
        require(
            SwapperLike(ilkInstance.swapper).ilk() == ilk,
            "AllocatorInit/swapper-ilk-mismatch"
        );
        require(
            SwapperLike(ilkInstance.swapper).buffer() == ilkInstance.buffer,
            "AllocatorInit/swapper-buffer-mismatch"
        );

        require(
            DepositorUniV3Like(ilkInstance.depositorUniV3).roles() ==
                sharedInstance.roles,
            "AllocatorInit/depositorUniV3-roles-mismatch"
        );
        require(
            DepositorUniV3Like(ilkInstance.depositorUniV3).ilk() == ilk,
            "AllocatorInit/depositorUniV3-ilk-mismatch"
        );
        require(
            DepositorUniV3Like(ilkInstance.depositorUniV3).uniV3Factory() ==
                cfg.uniV3Factory,
            "AllocatorInit/depositorUniV3-uniV3Factory-mismatch"
        );
        require(
            DepositorUniV3Like(ilkInstance.depositorUniV3).buffer() ==
                ilkInstance.buffer,
            "AllocatorInit/depositorUniV3-buffer-mismatch"
        );

        require(
            VaultMinterLike(ilkInstance.vaultMinter).vault() ==
                ilkInstance.vault,
            "AllocatorInit/vaultMinter-vault-mismatch"
        );

        require(
            StableSwapperLike(ilkInstance.stableSwapper).swapper() ==
                ilkInstance.swapper,
            "AllocatorInit/stableSwapper-swapper-mismatch"
        );
        require(
            StableDepositorUniV3Like(ilkInstance.stableDepositorUniV3)
                .depositor() == ilkInstance.depositorUniV3,
            "AllocatorInit/stableDepositorUniV3-depositorUniV3-mismatch"
        );

        require(
            ConduitMoverLike(ilkInstance.conduitMover).ilk() == ilk,
            "AllocatorInit/conduitMover-ilk-mismatch"
        );
        require(
            ConduitMoverLike(ilkInstance.conduitMover).buffer() ==
                ilkInstance.buffer,
            "AllocatorInit/conduitMover-buffer-mismatch"
        );

        // Onboard the ilk
        dss.vat.init(ilk);
        dss.jug.init(ilk);

        require(
            (cfg.duty >= RAY) && (cfg.duty <= RATES_ONE_HUNDRED_PCT),
            "AllocatorInit/ilk-duty-out-of-bounds"
        );
        dss.jug.file(ilk, "duty", cfg.duty);

        dss.vat.file(ilk, "line", cfg.gap);
        dss.vat.file("Line", dss.vat.Line() + cfg.gap);
        AutoLineLike(dss.chainlog.getAddress("MCD_IAM_AUTO_LINE")).setIlk(
            ilk,
            cfg.maxLine,
            cfg.gap,
            cfg.ttl
        );

        dss.spotter.file(ilk, "pip", sharedInstance.oracle);
        dss.spotter.file(ilk, "mat", RAY);
        dss.spotter.poke(ilk);

        // Add buffer to registry
        RegistryLike(sharedInstance.registry).file(
            ilk,
            "buffer",
            ilkInstance.buffer
        );

        // Initiate the allocator vault
        dss.vat.slip(ilk, ilkInstance.vault, int256(10 ** 12 * WAD));
        dss.vat.grab(
            ilk,
            ilkInstance.vault,
            ilkInstance.vault,
            address(0),
            int256(10 ** 12 * WAD),
            0
        );

        VaultLike(ilkInstance.vault).file("jug", address(dss.jug));

        // Allow vault and funnels to pull funds from the buffer
        BufferLike(ilkInstance.buffer).approve(
            VaultLike(ilkInstance.vault).nst(),
            ilkInstance.vault,
            type(uint256).max
        );
        for (uint256 i = 0; i < cfg.swapTokens.length; i++) {
            BufferLike(ilkInstance.buffer).approve(
                cfg.swapTokens[i],
                ilkInstance.swapper,
                type(uint256).max
            );
        }
        for (uint256 i = 0; i < cfg.depositTokens.length; i++) {
            BufferLike(ilkInstance.buffer).approve(
                cfg.depositTokens[i],
                ilkInstance.depositorUniV3,
                type(uint256).max
            );
        }

        // Set the pause proxy temporarily as ilk admin so we can set all the roles below
        RolesLike(sharedInstance.roles).setIlkAdmin(ilk, ilkInstance.owner);

        // Allow the facilitators to operate on the vault and funnels directly
        for (uint256 i = 0; i < cfg.facilitators.length; i++) {
            RolesLike(sharedInstance.roles).setUserRole(
                ilk,
                cfg.facilitators[i],
                cfg.facilitatorRole,
                true
            );
        }

        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.facilitatorRole,
            ilkInstance.vault,
            VaultLike.draw.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.facilitatorRole,
            ilkInstance.vault,
            VaultLike.wipe.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.facilitatorRole,
            ilkInstance.swapper,
            SwapperLike.swap.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.facilitatorRole,
            ilkInstance.depositorUniV3,
            DepositorUniV3Like.deposit.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.facilitatorRole,
            ilkInstance.depositorUniV3,
            DepositorUniV3Like.withdraw.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.facilitatorRole,
            ilkInstance.depositorUniV3,
            DepositorUniV3Like.collect.selector,
            true
        );

        // Allow the automation contracts to operate on the funnels
        RolesLike(sharedInstance.roles).setUserRole(
            ilk,
            ilkInstance.vaultMinter,
            cfg.automationRole,
            true
        );
        RolesLike(sharedInstance.roles).setUserRole(
            ilk,
            ilkInstance.stableSwapper,
            cfg.automationRole,
            true
        );
        RolesLike(sharedInstance.roles).setUserRole(
            ilk,
            ilkInstance.stableDepositorUniV3,
            cfg.automationRole,
            true
        );

        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.automationRole,
            ilkInstance.vault,
            VaultLike.draw.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.automationRole,
            ilkInstance.vault,
            VaultLike.wipe.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.automationRole,
            ilkInstance.swapper,
            SwapperLike.swap.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.automationRole,
            ilkInstance.depositorUniV3,
            DepositorUniV3Like.deposit.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.automationRole,
            ilkInstance.depositorUniV3,
            DepositorUniV3Like.withdraw.selector,
            true
        );
        RolesLike(sharedInstance.roles).setRoleAction(
            ilk,
            cfg.automationRole,
            ilkInstance.depositorUniV3,
            DepositorUniV3Like.collect.selector,
            true
        );

        // Set the allocator proxy as the ilk admin instead of the Pause Proxy
        RolesLike(sharedInstance.roles).setIlkAdmin(ilk, cfg.allocatorProxy);

        // Allow facilitator to set configurations in the automation contracts
        for (uint256 i = 0; i < cfg.facilitators.length; i++) {
            WardsLike(ilkInstance.vaultMinter).rely(cfg.facilitators[i]);
            WardsLike(ilkInstance.stableSwapper).rely(cfg.facilitators[i]);
            WardsLike(ilkInstance.stableDepositorUniV3).rely(
                cfg.facilitators[i]
            );
            WardsLike(ilkInstance.conduitMover).rely(cfg.facilitators[i]);
        }

        // Add keepers to the automation contracts
        for (uint256 i = 0; i < cfg.vaultMinterKeepers.length; i++) {
            KissLike(ilkInstance.vaultMinter).kiss(cfg.vaultMinterKeepers[i]);
        }
        for (uint256 i = 0; i < cfg.stableSwapperKeepers.length; i++) {
            KissLike(ilkInstance.stableSwapper).kiss(
                cfg.stableSwapperKeepers[i]
            );
        }
        for (uint256 i = 0; i < cfg.stableDepositorUniV3Keepers.length; i++) {
            KissLike(ilkInstance.stableDepositorUniV3).kiss(
                cfg.stableDepositorUniV3Keepers[i]
            );
        }
        for (uint256 i = 0; i < cfg.conduitMoverKeepers.length; i++) {
            KissLike(ilkInstance.conduitMover).kiss(cfg.conduitMoverKeepers[i]);
        }

        // Move ownership of the ilk contracts to the allocator proxy
        ScriptTools.switchOwner(
            ilkInstance.vault,
            ilkInstance.owner,
            cfg.allocatorProxy
        );
        ScriptTools.switchOwner(
            ilkInstance.buffer,
            ilkInstance.owner,
            cfg.allocatorProxy
        );
        ScriptTools.switchOwner(
            ilkInstance.swapper,
            ilkInstance.owner,
            cfg.allocatorProxy
        );
        ScriptTools.switchOwner(
            ilkInstance.depositorUniV3,
            ilkInstance.owner,
            cfg.allocatorProxy
        );
        ScriptTools.switchOwner(
            ilkInstance.vaultMinter,
            ilkInstance.owner,
            cfg.allocatorProxy
        );
        ScriptTools.switchOwner(
            ilkInstance.stableSwapper,
            ilkInstance.owner,
            cfg.allocatorProxy
        );
        ScriptTools.switchOwner(
            ilkInstance.stableDepositorUniV3,
            ilkInstance.owner,
            cfg.allocatorProxy
        );
        ScriptTools.switchOwner(
            ilkInstance.conduitMover,
            ilkInstance.owner,
            cfg.allocatorProxy
        );

        // Add allocator-specific contracts to changelog
        string memory ilkString = ScriptTools.ilkToChainlogFormat(ilk);
        dss.chainlog.setAddress(
            ScriptTools.stringToBytes32(
                string(abi.encodePacked(ilkString, "_VAULT"))
            ),
            ilkInstance.vault
        );
        dss.chainlog.setAddress(
            ScriptTools.stringToBytes32(
                string(abi.encodePacked(ilkString, "_BUFFER"))
            ),
            ilkInstance.buffer
        );
        dss.chainlog.setAddress(
            ScriptTools.stringToBytes32(
                string(abi.encodePacked("PIP_", ilkString))
            ),
            sharedInstance.oracle
        );

        // Add to ilk registry
        IlkRegistryLike(cfg.ilkRegistry).put({
            _ilk: ilk,
            _join: address(0),
            _gem: address(0),
            _dec: 0,
            _class: 5, // RWAs are class 3, D3Ms and Teleport are class 4
            _pip: sharedInstance.oracle,
            _xlip: address(0),
            _name: bytes32ToStr(ilk),
            _symbol: bytes32ToStr(ilk)
        });
    }
}


AllocatorInit

// SPDX-FileCopyrightText: © 2023 Dai Foundation <www.daifoundation.org>
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

struct AllocatorSharedInstance {
    address oracle;
    address roles;
    address registry;
}

struct AllocatorIlkInstance {
    address owner;
    address vault;
    address buffer;
    address swapper;
    address depositorUniV3;
    address vaultMinter;
    address stableSwapper;
    address stableDepositorUniV3;
    address conduitMover;
}


canCall

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-auth
interface DSAuthorityAbstract {
    function canCall(address, address, bytes4) external view returns (bool);
}

interface DSAuthAbstract {
    function authority() external view returns (address);
    function owner() external view returns (address);
    function setOwner(address) external;
    function setAuthority(address) external;
}


DSAuthorityAbstract

MAX_YAYS

_capability_roles

_public_capabilities

_root_users

_user_roles

approvals

deposits

etch

free

getCapabilityRoles

getUserRoles

hasUserRole

isCapabilityPublic

isUserRoot

launch

lift

live

lock

setAuthority

setOwner

setPublicCapability

setRoleCapability

setRootUser

setUserRole

slates

vote

votes

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-chief
interface DSChiefAbstract {
    function live() external view returns (uint256);
    function launch() external;
    function slates(bytes32) external view returns (address[] memory);
    function votes(address) external view returns (bytes32);
    function approvals(address) external view returns (uint256);
    function deposits(address) external view returns (address);
    function GOV() external view returns (address);
    function IOU() external view returns (address);
    function hat() external view returns (address);
    function MAX_YAYS() external view returns (uint256);
    function lock(uint256) external;
    function free(uint256) external;
    function etch(address[] calldata) external returns (bytes32);
    function vote(address[] calldata) external returns (bytes32);
    function vote(bytes32) external;
    function lift(address) external;
    function setOwner(address) external;
    function setAuthority(address) external;
    function isUserRoot(address) external view returns (bool);
    function setRootUser(address, bool) external;
    function _root_users(address) external view returns (bool);
    function _user_roles(address) external view returns (bytes32);
    function _capability_roles(address, bytes4) external view returns (bytes32);
    function _public_capabilities(address, bytes4) external view returns (bool);
    function getUserRoles(address) external view returns (bytes32);
    function getCapabilityRoles(address, bytes4) external view returns (bytes32);
    function isCapabilityPublic(address, bytes4) external view returns (bool);
    function hasUserRole(address, uint8) external view returns (bool);
    function canCall(address, address, bytes4) external view returns (bool);
    function setUserRole(address, uint8, bool) external;
    function setPublicCapability(address, bytes4, bool) external;
    function setRoleCapability(uint8, address, bytes4, bool) external;
}

interface DSChiefFabAbstract {
    function newChief(address, uint256) external returns (address);
}


DSChiefAbstract

authority

delay

drop

exec

owner

plans

plot

proxy

setDelay

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-pause
interface DSPauseAbstract {
    function owner() external view returns (address);
    function authority() external view returns (address);
    function setOwner(address) external;
    function setAuthority(address) external;
    function setDelay(uint256) external;
    function plans(bytes32) external view returns (bool);
    function proxy() external view returns (address);
    function delay() external view returns (uint256);
    function plot(address, bytes32, bytes calldata, uint256) external;
    function drop(address, bytes32, bytes calldata, uint256) external;
    function exec(address, bytes32, bytes calldata, uint256) external returns (bytes memory);
}


DSPauseAbstract

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-pause
interface DSPauseProxyAbstract {
    function owner() external view returns (address);
    function exec(address, bytes calldata) external returns (bytes memory);
}


DSPauseProxyAbstract

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-roles
interface DSRolesAbstract {
    function _root_users(address) external view returns (bool);
    function _user_roles(address) external view returns (bytes32);
    function _capability_roles(address, bytes4) external view returns (bytes32);
    function _public_capabilities(address, bytes4) external view returns (bool);
    function getUserRoles(address) external view returns (bytes32);
    function getCapabilityRoles(address, bytes4) external view returns (bytes32);
    function isUserRoot(address) external view returns (bool);
    function isCapabilityPublic(address, bytes4) external view returns (bool);
    function hasUserRole(address, uint8) external view returns (bool);
    function canCall(address, address, bytes4) external view returns (bool);
    function setRootUser(address, bool) external;
    function setUserRole(address, uint8, bool) external;
    function setPublicCapability(address, bytes4, bool) external;
    function setRoleCapability(uint8, address, bytes4, bool) external;
    function authority() external view returns (address);
    function owner() external view returns (address);
    function setOwner(address) external;
    function setAuthority(address) external;
}


DSRolesAbstract

action

cast

done

pause

schedule

// SPDX-License-Identifier: AGPL-3.0-or-later

// Copyright (C) 2020 Maker Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity >=0.5.12;

// https://github.com/makerdao/dss-spellbook
interface DSRuneAbstract {
    // @return [address] A contract address conforming to DSPauseAbstract
    function pause()    external view returns (address);
    // @return [address] The address of the contract to be executed
    // TODO: is `action()` a required field? Not all spells rely on a seconary contract.
    function action()   external view returns (address);
    // @return [bytes32] extcodehash of rune address
    function tag()      external view returns (bytes32);
    // @return [bytes] The `abi.encodeWithSignature()` result of the function to be called.
    function sig()      external view returns (bytes memory);
    // @return [uint256] Earliest time rune can execute
    function eta()      external view returns (uint256);
    // The schedule() function plots the rune in the DSPause
    function schedule() external;
    // @return [bool] true if the rune has been cast()
    function done()     external view returns (bool);
    // The cast() function executes the rune
    function cast()     external;
}


DSRuneAbstract

data

mana

whom

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-spell
interface DSSpellAbstract {
    function whom() external view returns (address);
    function mana() external view returns (uint256);
    function data() external view returns (bytes memory);
    function done() external view returns (bool);
    function cast() external;
}


DSSpellAbstract

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-thing
interface DSThingAbstract {
    function authority() external view returns (address);
    function owner() external view returns (address);
    function setOwner(address) external;
    function setAuthority(address) external;
}


DSThingAbstract

allowance

approve

balanceOf

burn

decimals

mint

move

name

pull

push

setName

symbol

totalSupply

transfer

transferFrom

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-token/blob/master/src/token.sol
interface DSTokenAbstract {
    function name() external view returns (bytes32);
    function symbol() external view returns (bytes32);
    function decimals() external view returns (uint256);
    function totalSupply() external view returns (uint256);
    function balanceOf(address) external view returns (uint256);
    function transfer(address, uint256) external returns (bool);
    function allowance(address, address) external view returns (uint256);
    function approve(address, uint256) external returns (bool);
    function approve(address) external returns (bool);
    function transferFrom(address, address, uint256) external returns (bool);
    function push(address, uint256) external;
    function pull(address, uint256) external;
    function move(address, address, uint256) external;
    function mint(uint256) external;
    function mint(address,uint) external;
    function burn(uint256) external;
    function burn(address,uint) external;
    function setName(bytes32) external;
    function authority() external view returns (address);
    function owner() external view returns (address);
    function setOwner(address) external;
    function setAuthority(address) external;
}


DSTokenAbstract

peek

poke

read

void

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/dapphub/ds-value/blob/master/src/value.sol
interface DSValueAbstract {
    function has() external view returns (bool);
    function val() external view returns (bytes32);
    function peek() external view returns (bytes32, bool);
    function read() external view returns (bytes32);
    function poke(bytes32) external;
    function void() external;
    function authority() external view returns (address);
    function owner() external view returns (address);
    function setOwner(address) external;
    function setAuthority(address) external;
}


DSValueAbstract

cage

deny

exit

join

rely

wards

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss-deploy/blob/master/src/join.sol
interface AuthGemJoinAbstract {
    function vat() external view returns (address);
    function ilk() external view returns (bytes32);
    function gem() external view returns (address);
    function dec() external view returns (uint256);
    function live() external view returns (uint256);
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function cage() external;
    function join(address, uint256) external;
    function exit(address, uint256) external;
}


AuthGemJoinAbstract

bite

claw

file

ilks

litter

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss/blob/master/src/cat.sol
interface CatAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function box() external view returns (uint256);
    function litter() external view returns (uint256);
    function ilks(bytes32) external view returns (address, uint256, uint256);
    function live() external view returns (uint256);
    function vat() external view returns (address);
    function vow() external view returns (address);
    function file(bytes32, address) external;
    function file(bytes32, uint256) external;
    function file(bytes32, bytes32, uint256) external;
    function file(bytes32, bytes32, address) external;
    function bite(bytes32, address) external returns (uint256);
    function claw(uint256) external;
    function cage() external;
}


CatAbstract

count

getAddress

ipfs

keys

list

removeAddress

setAddress

setIPFS

setSha256sum

setVersion

version

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss-chain-log
interface ChainlogAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function keys() external view returns (bytes32[] memory);
    function version() external view returns (string memory);
    function ipfs() external view returns (string memory);
    function setVersion(string calldata) external;
    function setSha256sum(string calldata) external;
    function setIPFS(string calldata) external;
    function setAddress(bytes32,address) external;
    function removeAddress(bytes32) external;
    function count() external view returns (uint256);
    function get(uint256) external view returns (bytes32,address);
    function list() external view returns (bytes32[] memory);
    function getAddress(bytes32) external view returns (address);
}

// Helper function for returning address or abstract of Chainlog
//  Valid on Mainnet, Kovan, Rinkeby, Ropsten, and Goerli
contract ChainlogHelper {
    address          public constant ADDRESS  = 0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F;
    ChainlogAbstract public constant ABSTRACT = ChainlogAbstract(ADDRESS);
}


ChainlogAbstract

active

calc

chip

chost

cusp

getStatus

kick

kicks

redo

sales

spotter

stopped

tail

take

upchost

yank

// SPDX-License-Identifier: AGPL-3.0-or-later

/// ClipAbstract.sol -- Clip Interface

// Copyright (C) 2021 Maker Ecosystem Growth Holdings, INC.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity >=0.5.12;

interface ClipAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function ilk() external view returns (bytes32);
    function vat() external view returns (address);
    function dog() external view returns (address);
    function vow() external view returns (address);
    function spotter() external view returns (address);
    function calc() external view returns (address);
    function buf() external view returns (uint256);
    function tail() external view returns (uint256);
    function cusp() external view returns (uint256);
    function chip() external view returns (uint64);
    function tip() external view returns (uint192);
    function chost() external view returns (uint256);
    function kicks() external view returns (uint256);
    function active(uint256) external view returns (uint256);
    function sales(uint256) external view returns (uint256,uint256,uint256,address,uint96,uint256);
    function stopped() external view returns (uint256);
    function file(bytes32,uint256) external;
    function file(bytes32,address) external;
    function kick(uint256,uint256,address,address) external returns (uint256);
    function redo(uint256,address) external;
    function take(uint256,uint256,uint256,address,bytes calldata) external;
    function count() external view returns (uint256);
    function list() external view returns (uint256[] memory);
    function getStatus(uint256) external view returns (bool,uint256,uint256,uint256);
    function upchost() external;
    function yank(uint256) external;
}


ClipAbstract

locked

setBreaker

setPriceTolerance

tolerance

tripBreaker

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/Clipper-mom/blob/master/src/ClipperMom.sol
interface ClipperMomAbstract {
    function owner() external view returns (address);
    function authority() external view returns (address);
    function locked(address) external view returns (uint256);
    function tolerance(address) external view returns (uint256);
    function spotter() external view returns (address);
    function setOwner(address) external;
    function setAuthority(address) external;
    function setPriceTolerance(address, uint256) external;
    function setBreaker(address, uint256, uint256) external;
    function tripBreaker(address) external;
}


ClipperMomAbstract

lCount

load

loadded

srcs

tCount

tell

wait

when

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss/blob/master/src/cure.sol
interface CureAbstract {
    function wards(address) external view returns (uint256);
    function live() external view returns (uint256);
    function srcs(uint256) external view returns (address);
    function wait() external view returns (uint256);
    function when() external view returns (uint256);
    function pos(address) external view returns (uint256);
    function amt(address) external view returns (uint256);
    function loadded(address) external view returns (uint256);
    function lCount() external view returns (uint256);
    function say() external view returns (uint256);
    function tCount() external view returns (uint256);
    function list() external view returns (address[] memory);
    function tell() external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function file(bytes32, uint256) external;
    function lift(address) external;
    function drop(address) external;
    function cage() external;
    function load(address) external;
}


CureAbstract

DOMAIN_SEPARATOR

PERMIT_TYPEHASH

nonces

permit

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss/blob/master/src/dai.sol
interface DaiAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function version() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint256);
    function balanceOf(address) external view returns (uint256);
    function allowance(address, address) external view returns (uint256);
    function nonces(address) external view returns (uint256);
    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external view returns (bytes32);
    function transfer(address, uint256) external returns (bool);
    function transferFrom(address, address, uint256) external returns (bool);
    function mint(address, uint256) external;
    function burn(address, uint256) external;
    function approve(address, uint256) external returns (bool);
    function push(address, uint256) external;
    function pull(address, uint256) external;
    function move(address, address, uint256) external;
    function permit(address, address, uint256, uint256, bool, uint8, bytes32, bytes32) external;
}


DaiAbstract

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss/blob/master/src/join.sol
interface DaiJoinAbstract {
    function wards(address) external view returns (uint256);
    function rely(address usr) external;
    function deny(address usr) external;
    function vat() external view returns (address);
    function dai() external view returns (address);
    function live() external view returns (uint256);
    function cage() external;
    function join(address, uint256) external;
    function exit(address, uint256) external;
}


DaiJoinAbstract

Dirt

Hole

bark

chop

digs

// SPDX-License-Identifier: AGPL-3.0-or-later

/// DogAbstract.sol -- Dog Interface

// Copyright (C) 2021 Maker Ecosystem Growth Holdings, INC.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity >=0.5.12;

interface DogAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function vat() external view returns (address);
    function ilks(bytes32) external view returns (address,uint256,uint256,uint256);
    function vow() external view returns (address);
    function live() external view returns (uint256);
    function Hole() external view returns (uint256);
    function Dirt() external view returns (uint256);
    function file(bytes32,address) external;
    function file(bytes32,uint256) external;
    function file(bytes32,bytes32,uint256) external;
    function file(bytes32,bytes32,address) external;
    function chop(bytes32) external view returns (uint256);
    function bark(bytes32,address,address) external returns (uint256);
    function digs(bytes32,uint256) external;
    function cage() external;
}


DogAbstract

remIlk

setIlk

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss-auto-line/blob/master/src/DssAutoLine.sol
interface DssAutoLineAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function vat() external view returns (address);
    function ilks(bytes32) external view returns (uint256,uint256,uint48,uint48,uint48);
    function setIlk(bytes32,uint256,uint256,uint256) external;
    function remIlk(bytes32) external;
    function exec(bytes32) external returns (uint256);
}


DssAutoLineAbstract

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss-cdp-manager/
interface DssCdpManagerAbstract {
    function vat() external view returns (address);
    function cdpi() external view returns (uint256);
    function urns(uint256) external view returns (address);
    function list(uint256) external view returns (uint256,uint256);
    function owns(uint256) external view returns (address);
    function ilks(uint256) external view returns (bytes32);
    function first(address) external view returns (uint256);
    function last(address) external view returns (uint256);
    function count(address) external view returns (uint256);
    function cdpCan(address, uint256, address) external returns (uint256);
    function urnCan(address, address) external returns (uint256);
    function cdpAllow(uint256, address, uint256) external;
    function urnAllow(address, uint256) external;
    function open(bytes32, address) external returns (uint256);
    function give(uint256, address) external;
    function frob(uint256, int256, int256) external;
    function flux(uint256, address, uint256) external;
    function flux(bytes32, uint256, address, uint256) external;
    function move(uint256, address, uint256) external;
    function quit(uint256, address) external;
    function enter(address, uint256) external;
    function shift(uint256, uint256) external;
}


cash

cure

debt

flow

pack

skim

skip

snip

spot

thaw

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss/blob/master/src/end.sol
interface EndAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function vat() external view returns (address);
    function cat() external view returns (address);
    function dog() external view returns (address);
    function vow() external view returns (address);
    function pot() external view returns (address);
    function spot() external view returns (address);
    function cure() external view returns (address);
    function live() external view returns (uint256);
    function when() external view returns (uint256);
    function wait() external view returns (uint256);
    function debt() external view returns (uint256);
    function tag(bytes32) external view returns (uint256);
    function gap(bytes32) external view returns (uint256);
    function Art(bytes32) external view returns (uint256);
    function fix(bytes32) external view returns (uint256);
    function bag(address) external view returns (uint256);
    function out(bytes32, address) external view returns (uint256);
    function file(bytes32, address) external;
    function file(bytes32, uint256) external;
    function cage() external;
    function cage(bytes32) external;
    function skip(bytes32, uint256) external;
    function snip(bytes32, uint256) external;
    function skim(bytes32, address) external;
    function free(bytes32) external;
    function thaw() external;
    function flow(bytes32) external;
    function pack(uint256) external;
    function cash(bytes32, uint256) external;
}


EndAbstract

denyProxy

fire

revokesGovernanceAccess

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/esm/blob/master/src/ESM.sol
interface ESMAbstract {
    function gem() external view returns (address);
    function proxy() external view returns (address);
    function wards(address) external view returns (uint256);
    function sum(address) external view returns (address);
    function Sum() external view returns (uint256);
    function min() external view returns (uint256);
    function end() external view returns (address);
    function live() external view returns (uint256);
    function revokesGovernanceAccess() external view returns (bool);
    function rely(address) external;
    function deny(address) external;
    function file(bytes32, uint256) external;
    function file(bytes32, address) external;
    function cage() external;
    function fire() external;
    function denyProxy(address) external;
    function join(uint256) external;
    function burn() external;
}


ESMAbstract

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/dss/blob/master/src/join.sol
interface ETHJoinAbstract {
    function wards(address) external view returns (uint256);
    function rely(address usr) external;
    function deny(address usr) external;
    function vat() external view returns (address);
    function ilk() external view returns (bytes32);
    function live() external view returns (uint256);
    function cage() external;
    function join(address) external payable;
    function exit(address, uint256) external;
}


ETHJoinAbstract

price

// SPDX-License-Identifier: AGPL-3.0-or-later

/// ExponentialDecreaseAbstract.sol -- Exponential Decrease Interface

// Copyright (C) 2021 Maker Ecosystem Growth Holdings, INC.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity >=0.5.12;

interface ExponentialDecreaseAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function cut() external view returns (uint256);
    function file(bytes32,uint256) external;
    function price(uint256,uint256) external view returns (uint256);
}


ExponentialDecreaseAbstract

gulp

hope

nope

setAmt

shut

undo

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.5.12;

// https://github.com/makerdao/token-faucet/blob/master/src/RestrictedTokenFaucet.sol
interface FaucetAbstract {
    function wards(address) external view returns (uint256);
    function rely(address) external;
    function deny(address) external;
    function list(address) external view returns (uint256);
    function hope(address) external;
    function nope(address) external;
    function amt(address) external view returns (uint256);
    function done(address, address) external view returns (bool);
    function gulp(address) external;
    function gulp(address, address[] calldata) external;
    function shut(address) external;
    function undo(address, address) external;
    function setAmt(address, uint256) external;
}


Builders of Dai, a digital currency that can be used by anyone, anywhere.
