Dao.sol

Main DAO smart contract

DAO is ERC20 itself, we call this token – GT (Governance Token). Balance in this token is voting power. Transfers are prohibited, but transfers with voting are allowed.

All voting are offchain (with signatures)

To create voting you need to generate hash, sign it with your private key, get the same signatures from your friends and provide them as argument to execute() function

function execute(
        address _target,
        bytes calldata _data,
        uint256 _value,
        uint256 _nonce,
        uint256 _timestamp,
        bytes[] memory _sigs
    ) external nonReentrant returns (bool) {
        require(checkSubscription(), "DAO: subscription not paid");

        require(balanceOf(msg.sender) > 0, "DAO: only for members");

        require(
            _timestamp + VOTING_DURATION >= block.timestamp,
            "DAO: voting is over"
        );

        bytes32 txHash = getTxHash(_target, _data, _value, _nonce, _timestamp);

        require(!executedTx[txHash], "DAO: voting already executed");

        require(_checkSigs(_sigs, txHash), "DAO: quorum is not reached");

        executedTx[txHash] = true;

        executedVotings.push(
            ExecutedVoting({
                target: _target,
                data: _data,
                value: _value,
                nonce: _nonce,
                timestamp: _timestamp,
                executionTimestamp: block.timestamp,
                txHash: txHash,
                sigs: _sigs
            })
        );

        if (_data.length == 0) {
            payable(_target).sendValue(_value);
        } else {
            if (_value == 0) {
                _target.functionCall(_data);
            } else {
                _target.functionCallWithValue(_data, _value);
            }
        }

        emit Executed(
            _target,
            _data,
            _value,
            _nonce,
            _timestamp,
            block.timestamp,
            txHash,
            _sigs
        );

        return true;
    }

JS Snippets to generate this you can find in test/utils.ts

export const createData = (
  func: string,
  argtypes: string[] = [],
  args: any[] = []
): string =>
  argtypes.length === 0 && args.length === 0
    ? id(`${func}()`).slice(0, 10) + new AbiCoder().encode([], []).slice(2)
    : id(`${func}(${argtypes.join(",")})`).slice(0, 10) +
      new AbiCoder().encode(argtypes, args).slice(2)

export const createTxHash = (
  daoAddress: string,
  target: string,
  data: string,
  value: BigNumberish,
  nonce: BigNumberish,
  timestamp: BigNumberish
): Uint8Array =>
  arrayify(
    keccak256(
      new AbiCoder().encode(
        ["address", "address", "bytes", "uint256", "uint256", "uint256"],
        [daoAddress, target, data, value, nonce, timestamp]
      )
    )
  )

Permitted Address Set – these addresses can execute from DAO without voting

function executePermitted(
        address _target,
        bytes calldata _data,
        uint256 _value
    ) external nonReentrant returns (bool) {
        require(checkSubscription(), "DAO: subscription not paid");

        require(permitted.contains(msg.sender), "DAO: only for permitted");

        if (_data.length == 0) {
            payable(_target).sendValue(_value);
        } else {
            if (_value == 0) {
                _target.functionCall(_data);
            } else {
                _target.functionCallWithValue(_data, _value);
            }
        }

        executedPermitted.push(
            ExecutedPermitted({
                target: _target,
                data: _data,
                value: _value,
                executionTimestamp: block.timestamp,
                executor: msg.sender
            })
        );

        emit ExecutedP(_target, _data, _value, msg.sender);

        return true;
    }

Adapters Address Set – these permitted contracts help to withdraw your share when you burn your LP tokens