Module admin_multisig

import smartpy as sp

"""
    A Multisig Contract used to administrate other contracts.
    THIS CONTRACT IS FOR ILLUSTRATIVE PURPOSE.
    IT HAS NOT BEEN AUDITED.
"""

@sp.module
def MS_TYPES():
    # Internal administration action type specification
    InternalAdminAction: type = sp.variant(
        changeSigners   = sp.variant(
                            removed = sp.set[sp.address],
                            added   = sp.list[
                                        sp.record(
                                            address     = sp.address,
                                            publicKey   = sp.key
                                        )
                            ]
                        ),
        changeQuorum    = sp.nat,
        changeMetadata  = sp.pair[sp.string, sp.option[sp.bytes]],
    )

    # External administration action type specification
    ExternalAdminAction: type = sp.record(
        target  = sp.address,
        actions = sp.bytes
    )

    # Proposal action type specification
    ProposalAction: type = sp.variant(
        internal = sp.list[InternalAdminAction],
        external = sp.list[ExternalAdminAction]
    )

    # Proposal type specification
    Proposal: type = sp.record(
        startedAt       = sp.timestamp,
        initiator       = sp.address,
        endorsements    = sp.set[sp.address],
        actions         = ProposalAction
    )

    AggregatedProposalParams: type = sp.record(
        signatures      = sp.list[
                            sp.record(
                                signerAddress   = sp.address,
                                signature       = sp.signature
                            )
        ],
        proposalId      = sp.nat,
        actions         = ProposalAction
    )


    AggregatedEndorsementParams: type = sp.list[
        sp.record(
            signatures      = sp.list[
                                sp.record(
                                    signerAddress   = sp.address,
                                    signature       = sp.signature
                                )
            ],
            proposalId      = sp.nat
        )
    ]

@sp.module
def ERR():
    Badsig                 = "MULTISIG_Badsig"
    ProposalUnknown        = "MULTISIG_ProposalUnknown"
    NotInitiator           = "MULTISIG_NotInitiator"
    SignerUnknown          = "MULTISIG_SignerUnknown"
    InvalidTarget          = "MULTISIG_InvalidTarget"
    MoreQuorumThanSigners  = "MULTISIG_MoreQuorumThanSigners"
    InvalidProposalId      = "MULTISIG_InvalidProposalId"


METADATA = {
    "name"          : "Generic Multisig Administrator",
    "version"       : "1",
    "description"   : "Generic Multisig Administrator",
    "source"        : {
        "tools": [ "SmartPy" ]
    },
    "interfaces"    : [ "TZIP-016" ],
}


@sp.module
def main():
    @sp.effects(with_storage="read-only")
    def failIfNotSigner(address):
        sp.cast(self.data.signers, sp.map[sp.address, sp.record(publicKey=sp.key, lastProposalId=sp.option[sp.nat])])
        assert self.data.signers.contains(address), ERR.SignerUnknown

    class MultisigAdmin(sp.Contract):
        def __init__(
                self,
                quorum,
                signers,
                metadata
            ):

            # Metadata helper
            # self.init_metadata("metadata", METADATA)

            self.data.quorum              = quorum
            self.data.lastProposalId      = 0
            self.data.signers             = signers
            self.data.proposals           = sp.big_map()
            self.data.activeProposals     = sp.set()
            self.data.metadata            = metadata

            sp.cast(self.data,
                sp.record(
                    quorum          = sp.nat,
                    lastProposalId  = sp.nat,
                    signers         = sp.map[
                                        sp.address,
                                        sp.record(
                                            publicKey       = sp.key,
                                            lastProposalId  = sp.option[sp.nat]
                                        )
                    ],
                    proposals       = sp.big_map[sp.nat, MS_TYPES.Proposal],
                    activeProposals = sp.set[sp.nat],
                    metadata        = sp.big_map[sp.string, sp.bytes],
                )
            )

        @sp.entrypoint
        def proposal(self, actions):
            """
                Each user can have at most one proposal active at a time.
                Submitting a new proposal overrides the previous one.
            """
            # Proposals can only be submitted by registered signers
            failIfNotSigner(sp.sender)

            # If the proposal initiator has an active proposal,
            # then replace that proposal with the new one
            signerLastProposalId = self.data.signers[sp.sender].lastProposalId
            with sp.match(signerLastProposalId):
                with sp.case.Some as id:
                    self.data.activeProposals.remove(id)

            # Increment proposal counter
            self.data.lastProposalId += 1
            proposalId = self.data.lastProposalId
            # Store new proposal
            self.data.activeProposals.add(proposalId)
            self.data.proposals[proposalId] = sp.record(
                startedAt       = sp.now,
                initiator       = sp.sender,
                endorsements    = sp.set(sp.sender),
                actions         = actions
            )
            # Update signer's last proposal
            self.data.signers[sp.sender].lastProposalId = sp.Some(proposalId)

            # Approve the proposal if quorum only requires 1 vote
            if self.data.quorum < 2:
                self.onApproved(
                    sp.record(
                        proposalId  = proposalId,
                        actions     = actions,
                    )
                )

        @sp.entrypoint
        def endorsement(self, endorsements):
            """
                Entrypoint used to submit endorsements to single/multiple proposals.
            """
            # Endorsements can only be submitted by registered signers
            failIfNotSigner(sp.sender)

            # Iterate over every endorsement
            for pId in endorsements:
                self.registerEndorsement(
                    sp.record(
                        proposalId      = pId,
                        signerAddress   = sp.sender
                    )
                )

                # Approve the proposal if quorum was reached
                proposal = self.data.proposals[pId]
                if sp.len(proposal.endorsements) >= self.data.quorum:
                    self.onApproved(
                        sp.record(
                            proposalId  = pId,
                            actions     = proposal.actions,
                        )
                    )

        @sp.entrypoint
        def aggregated_proposal(self, params):
            """
                Users can send aggregated proposal, which are signed offchain and validated onchain.
            """
            sp.cast(params, MS_TYPES.AggregatedProposalParams)
            failIfNotSigner(sp.sender)

            self.data.lastProposalId += 1
            assert self.data.lastProposalId == params.proposalId, ERR.InvalidProposalId

            proposal = sp.record(
                startedAt       = sp.now,
                initiator       = sp.sender,
                endorsements    = sp.set(sp.sender),
                actions         = params.actions
            )

            # If the proposal initiator has an active proposal,
            # then replace that proposal with the new one
            proposerLastProposalId = self.data.signers[sp.sender].lastProposalId
            with sp.match(proposerLastProposalId):
                with sp.case.Some as id:
                    self.data.activeProposals.remove(id)
            self.data.signers[sp.sender].lastProposalId = sp.Some(params.proposalId)

            self.data.activeProposals.add(params.proposalId)
            self.data.proposals[params.proposalId] = proposal

            preSignature    = sp.pack(
                sp.record(
                    actions         = params.actions,
                    # (contractAddress + proposalId) protect against replay attacks
                    proposalId      = params.proposalId,
                    contractAddress = sp.self_address(),
                )
            )


            # Validate and apply endorsements
            for signature in params.signatures:
                failIfNotSigner(signature.signerAddress)

                publicKey = self.data.signers[signature.signerAddress].publicKey
                assert sp.check_signature(publicKey, signature.signature, preSignature), ERR.Badsig

                proposal.endorsements.add(signature.signerAddress)

            # Check quorum
            if sp.len(proposal.endorsements) >= self.data.quorum:
                self.onApproved(
                    sp.record(
                        proposalId  = params.proposalId,
                        actions     = proposal.actions,
                    )
                )

        @sp.entrypoint
        def aggregated_endorsement(self, endorsements):
            """
                Users can send aggregated votes, which are signed offchain and validated onchain.
            """
            sp.cast(endorsements, MS_TYPES.AggregatedEndorsementParams)

            for endorsement in endorsements:
                for signature in endorsement.signatures:
                    failIfNotSigner(signature.signerAddress)
                    preSignature = sp.pack(
                        sp.record(
                            # (contractAddress + proposalId) protect against replay attacks
                            contractAddress = sp.self_address(),
                            proposalId      = endorsement.proposalId
                        )
                    )
                    publicKey = self.data.signers[signature.signerAddress].publicKey
                    assert sp.check_signature(publicKey, signature.signature, preSignature), ERR.Badsig
                    self.registerEndorsement(
                        sp.record(
                            proposalId      = endorsement.proposalId,
                            signerAddress   = signature.signerAddress
                        )
                    )
                proposal = self.data.proposals[endorsement.proposalId]
                if sp.len(proposal.endorsements) >= self.data.quorum:
                    self.onApproved(
                        sp.record(
                            proposalId  = endorsement.proposalId,
                            actions     = proposal.actions,
                        )
                    )

        @sp.entrypoint
        def cancel_proposal(self, proposalId):
            failIfNotSigner(sp.sender)

            # Signers can only cancel their own proposals
            assert self.data.proposals[proposalId].initiator == sp.sender, ERR.NotInitiator
            self.data.activeProposals.remove(proposalId)

        @sp.private(with_storage="read-write")
        def registerEndorsement(self, params):
            assert self.data.activeProposals.contains(params.proposalId), ERR.ProposalUnknown
            # Add endorsement to proposal
            self.data.proposals[params.proposalId].endorsements.add(params.signerAddress)

        @sp.private(with_storage="read-write", with_operations=True)
        def onApproved(self, params):
            with sp.match(params.actions):
                # Internal actions are applied to the multisig contract
                with sp.case.internal as internalActions:
                    for action in internalActions:
                        with sp.match(action):
                            with sp.case.changeQuorum as quorum:
                                self.data.quorum = quorum
                            with sp.case.changeMetadata as metadata:
                                (k, v) = metadata
                                if v.is_some():
                                    self.data.metadata[k] = v.unwrap_some()
                                else:
                                    del self.data.metadata[k]

                            with sp.case.changeSigners as changeSigners:
                                with sp.match(changeSigners):
                                    with sp.case.removed as removeSet:
                                        for address in removeSet.elements():
                                            if self.data.signers.contains(address):
                                                # Remove signer
                                                del self.data.signers[address]
                                                # We don't remove signer[address].lastProposalId
                                                # because we remove all activeProposals after it.
                                    with sp.case.added as addList:
                                        for signer in addList:
                                            self.data.signers[signer.address]   = sp.record(
                                                                                    publicKey       = signer.publicKey,
                                                                                    lastProposalId  = None
                                                                                )
                        # Ensure that the contract never requires more quorum than the total of signers.
                        assert self.data.quorum <= sp.len(self.data.signers), ERR.MoreQuorumThanSigners
                    # Removes all active proposals after an administrative change.
                    self.data.activeProposals = sp.set()
                # External actions are applied to other contracts
                with sp.case.external as externalActions:
                    for action in externalActions:
                        target = sp.contract(sp.bytes, action.target).unwrap_some(error=ERR.InvalidTarget)
                        sp.transfer(action.actions, sp.tez(0), target)

            self.data.activeProposals.remove(params.proposalId)


@sp.module
def helpers():
    AdministrationType: type = sp.variant(
        changeAdmin    = sp.address,
        changeActive   = sp.bool
    )

    class Administrated(sp.Contract):
        """
            This contract is a sample
            It shows how a contract can be administrated
            through the multisig administration contract
        """
        def __init__(self, admin, active):
            self.data.admin = admin
            self.data.active = active

        @sp.entrypoint
        def administrate(self, actionsBytes):
            assert sp.sender == self.data.admin, "NOT ADMIN"

            # actionsBytes is packed and must be unpacked
            actions = sp.unpack(actionsBytes, sp.list[AdministrationType]).unwrap_some(error="Actions are invalid")

            for action in actions:
                with sp.match(action):
                    with sp.case.changeActive as active:
                        self.data.active = active
                    with sp.case.changeAdmin as admin:
                        self.data.admin = admin

        @sp.entrypoint
        def verifyActive(self):
            assert self.data.active, "NOT ACTIVE"


if "templates" not in __name__:
    #########
    # Helpers

    class InternalHelper():
        def variant(content):
            return sp.variant("internal", content)

        def changeQuorum(quorum):
            return sp.variant("changeQuorum", quorum)

        def removeSigners(l):
            return sp.variant("changeSigners",
                sp.variant("removed", sp.set(l))
            )

        def addSigners(l):
            added_list = []
            for added_info in l:
                addr, publicKey = added_info
                added_list.append(
                    sp.record(
                        address = addr,
                        publicKey = publicKey)
                    )
            return sp.variant("changeSigners",
                sp.variant("added", sp.list(added_list))
            )

    class ExternalHelper():
        def variant(content):
            return sp.variant("external", content)

        def changeActive(active):
            return sp.variant("changeActive", active)

        def changeAdmin(address):
            return sp.variant("changeAdmin", address)

    def sign(account, contract):
        message = sp.pack(
            sp.record(
                contractAddress = contract.address,
                proposalId      = contract.data.lastProposalId
            )
        )
        signature = sp.make_signature(account.secret_key, message, message_format = 'Raw')
        vote = sp.record(
            signerAddress   = account.address,
            signature       = signature
        )
        return vote

    def packActions(actions):
        actions = sp.set_type_expr(actions, sp.TList(helpers.AdministrationType))
        return sp.pack(actions)

    def add_test(internal_tests, is_default = True):
        name = "Internal Administration tests" if internal_tests else "External Administration tests"
        @sp.add_test(name = name, is_default = is_default)
        def test():
            sc = sp.test_scenario([MS_TYPES, ERR, main, helpers])
            sc.h1(name)

            admin = sp.test_account("admin")
            signer1 = sp.test_account("signer1")
            signer2 = sp.test_account("signer2")
            signer3 = sp.test_account("signer3")
            signer4 = sp.test_account("signer4")

            if internal_tests:

                sc.h3("Originate Multisig Admin")
                multisigAdmin = main.MultisigAdmin(
                    quorum              = 1,
                    signers             = sp.map(
                                            {
                                                signer1.address : sp.record(
                                                                    publicKey       = signer1.public_key,
                                                                    lastProposalId  = sp.none
                                                                ),
                                                signer2.address : sp.record(
                                                                    publicKey       = signer2.public_key,
                                                                    lastProposalId  = sp.none
                                                                )
                                            }
                                        ),
                    metadata         = sp.utils.metadata_of_url("ipfs://")
                )
                sc += multisigAdmin

                ##########################
                # Auto-accepted proposal #
                ##########################
                sc.h2("Auto-accepted proposal when quorum is 1")
                sc.h3("signer1 propose to change quorum to 2")
                sc.verify(multisigAdmin.data.quorum == 1)
                changeQuorum = InternalHelper.changeQuorum(2)
                multisigAdmin.proposal(InternalHelper.variant([changeQuorum])).run(sender = signer1)
                sc.verify(multisigAdmin.data.quorum == 2)

                ####################
                # Add a 3rd signer #
                ####################
                sc.h2("Adding a 3rd signer")
                sc.h3("signer2 new proposal to include signer3")
                sc.verify(sp.len(multisigAdmin.data.signers) == 2)
                sc.verify(~multisigAdmin.data.signers.contains(signer3.address))
                changeSigners = InternalHelper.addSigners([(signer3.address, signer3.public_key)])
                multisigAdmin.proposal(InternalHelper.variant([changeSigners])).run(sender = signer2)
                sc.h3("signer1 votes the proposal")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer1)
                sc.verify(multisigAdmin.data.signers.contains(signer3.address))
                sc.verify(sp.len(multisigAdmin.data.signers) == 3)

                ############################################
                # New proposal (change Quorum from 2 to 3) #
                ############################################
                sc.h2("New proposal (change Quorum from 2 to 3)")
                sc.h3("signer1 new proposal to change quorum to 3")
                changeQuorum = InternalHelper.changeQuorum(3)
                multisigAdmin.proposal(InternalHelper.variant([changeQuorum])).run(sender = signer1)
                # Proposal has not been validated yet
                sc.verify(multisigAdmin.data.quorum == 2)
                sc.h3("signer2 votes the proposal (2/2)")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer2)
                sc.verify(multisigAdmin.data.quorum == 3)

                ###########################################
                # Newly included signer starts a proposal #
                ###########################################
                sc.h2("Newly included signer starts a proposal")
                sc.h3("New proposal by signer 3 to decrease quorum to 2")
                changeQuorum = InternalHelper.changeQuorum(2)
                multisigAdmin.proposal(InternalHelper.variant([changeQuorum])).run(sender = signer3)
                sc.h3("signer1 votes the proposal")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer1)
                sc.verify(multisigAdmin.data.quorum == 3)
                sc.h3("signer2 votes the proposal")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer2)
                sc.verify(multisigAdmin.data.quorum == 2)

                ##########
                # Cancel #
                ##########
                sc.h2("Proposal cancellation")
                sc.h3("New proposal by signer 1")
                changeTimeout = InternalHelper.changeQuorum(3)
                multisigAdmin.proposal(InternalHelper.variant([changeTimeout])).run(sender = signer1)
                sc.verify(sp.len(multisigAdmin.data.activeProposals) == 1)
                sc.h3("Signer 2 tries to cancel the proposal (must fail, only the initiator can cancel)")
                multisigAdmin.cancel_proposal(multisigAdmin.data.lastProposalId).run(sender = signer2, valid = False)
                sc.h3("Signer 1 cancels the proposal")
                multisigAdmin.cancel_proposal(multisigAdmin.data.lastProposalId).run(sender = signer1)
                sc.verify(sp.len(multisigAdmin.data.activeProposals) == 0)
                sc.h3("Signer 2 tries to vote the canceled proposal")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer2, valid = False)
                sc.verify(multisigAdmin.data.quorum != 3)

                ######################
                # 2 actions proposal #
                ######################
                sc.h2("2 actions proposal")
                sc.h3("Signer 1 new proposal: change quorum to 2 and add signer 4")
                sc.verify(~multisigAdmin.data.signers.contains(signer4.address))
                changeQuorum = InternalHelper.changeQuorum(3)
                changeSigners = InternalHelper.addSigners([(signer4.address, signer4.public_key)])
                multisigAdmin.proposal(InternalHelper.variant([changeQuorum, changeSigners])).run(sender = signer1)
                sc.h3("Signer 2 votes the proposal")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer2)
                sc.verify(multisigAdmin.data.quorum == 3)
                sc.verify(multisigAdmin.data.signers.contains(signer4.address))

                #########################################
                # 2 Internal proposals at the same time #
                #########################################
                sc.h3("Signer 1 new proposal: change quorum to 2 and remove signer 4")
                changeQuorum = InternalHelper.changeQuorum(2)
                multisigAdmin.proposal(InternalHelper.variant([changeQuorum])).run(sender = signer1)
                changeSigners = InternalHelper.removeSigners([signer4.address])
                multisigAdmin.proposal(InternalHelper.variant([changeSigners])).run(sender = signer2)
                sc.verify(sp.len(multisigAdmin.data.activeProposals) == 2)
                sc.h3("Signer 3 votes on quorum proposal")
                multisigAdmin.endorsement([sp.as_nat(multisigAdmin.data.lastProposalId - 1)]).run(sender = signer3)
                sc.h3("Signer 4 votes on signers proposal")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer4)
                sc.h3("Confirm that nothing has changed")
                sc.verify(multisigAdmin.data.quorum == 3)
                sc.verify(multisigAdmin.data.signers.contains(signer4.address))
                sc.h3("Signer 4 votes on quorum proposal")
                multisigAdmin.endorsement([sp.as_nat(multisigAdmin.data.lastProposalId - 1)]).run(sender = signer4)
                sc.h3("Confirm that quorum was updated and signers proposal was canceled")
                sc.verify(sp.len(multisigAdmin.data.activeProposals) == 0)
                sc.verify(multisigAdmin.data.quorum == 2)
                sc.verify(multisigAdmin.data.signers.contains(signer4.address))

                #########################
                # Multisig endorsements #
                #########################
                sc.h2("Multi vote in one call")
                sc.h3("Signer 1 new proposal")
                changeQuorum = InternalHelper.changeQuorum(3)
                multisigAdmin.proposal(InternalHelper.variant([changeQuorum])).run(sender = signer1)
                sc.h3("Signer 2 and Signer 3 votes are pushed by Signer 1")
                signer2_endorsement = sign(signer2, contract = multisigAdmin)
                signer3_endorsement = sign(signer3, contract = multisigAdmin)
                proposalEndorsements = sp.record(
                    proposalId = multisigAdmin.data.lastProposalId,
                    signatures = [signer2_endorsement, signer3_endorsement]
                )
                multisigAdmin.aggregated_endorsement([proposalEndorsements]).run(sender = signer1)
                sc.verify(multisigAdmin.data.quorum == 3)

                #####################
                # Multisig proposal #
                #####################
                sc.h2("Multi vote in one call")
                sc.h3("Signer 1 new proposal")
                changeQuorum = InternalHelper.changeQuorum(3)
                multisigAdmin.proposal(InternalHelper.variant([changeQuorum])).run(sender = signer1)
                sc.h3("Signer 2 and Signer 3 votes are pushed by Signer 1")
                signer2_vote = sign(signer2, contract = multisigAdmin)
                signer3_vote = sign(signer3, contract = multisigAdmin)
                proposalVotes = sp.record(
                    proposalId = multisigAdmin.data.lastProposalId,
                    signatures = [signer2_vote, signer3_vote]
                )
                multisigAdmin.aggregated_endorsement([proposalVotes]).run(sender = signer1)
                sc.verify(multisigAdmin.data.quorum == 3)

            ##########################################

            else:

                sc.h3("Originate Multisig Admin")
                multisigAdmin = main.MultisigAdmin(
                    quorum              = 3,
                    signers             = sp.map(
                                            {
                                                signer1.address : sp.record(
                                                                    publicKey       = signer1.public_key,
                                                                    lastProposalId  = sp.none
                                                                ),
                                                signer2.address : sp.record(
                                                                    publicKey       = signer2.public_key,
                                                                    lastProposalId  = sp.none
                                                                ),
                                                signer3.address : sp.record(
                                                                    publicKey       = signer3.public_key,
                                                                    lastProposalId  = sp.none
                                                                )
                                            }
                                        ),
                    metadata         = sp.utils.metadata_of_url("ipfs://")
                )
                sc += multisigAdmin

                sc.h3("Originate administrated contract")
                administrated = helpers.Administrated(admin.address, False)
                sc += administrated
                administrated_entrypoint = sp.contract(sp.TBytes, administrated.address, entrypoint="administrate").open_some()

                sc.h2("Set multisig as admin of administrated contract")
                sc.verify(administrated.data.active == False)
                sc.verify(administrated.data.admin == admin.address)
                actions = packActions([ExternalHelper.changeAdmin(multisigAdmin.address)])
                administrated.administrate(actions).run(sender = admin)
                sc.verify(administrated.data.active == False)
                sc.verify(administrated.data.admin == multisigAdmin.address)

                sc.h2("Activate the administrated contract")
                sc.h3("Signer 1 new proposal: changeActive")
                actions = packActions([ExternalHelper.changeActive(True)])
                multisigAdmin.proposal(ExternalHelper.variant(
                    [sp.record(
                        target  = sp.to_address(administrated_entrypoint),
                        actions = actions
                    )]
                )).run(sender = signer1)
                sc.verify(administrated.data.active == False)
                sc.h3("Signer 2 votes")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer2)
                sc.verify(administrated.data.active == False)
                sc.h3("Signer 3 votes")
                multisigAdmin.endorsement([multisigAdmin.data.lastProposalId]).run(sender = signer3)
                sc.verify(administrated.data.active == True)

                sc.h2("Use Multisig vote to deactivate the administrated contract")
                sc.h3("Signer 1 new proposal: changeActive")
                actions = packActions([ExternalHelper.changeActive(False)])
                multisigAdmin.proposal(ExternalHelper.variant(
                    [sp.record(
                        target  = sp.to_address(administrated_entrypoint),
                        actions = actions
                    )]
                )).run(sender = signer1)
                sc.verify(administrated.data.active == True)
                sc.h3("Signer 2 and Signer 3 votes are pushed by Signer 1")
                signer2_vote = sign(signer2, contract = multisigAdmin)
                signer3_vote = sign(signer3, contract = multisigAdmin)
                proposalVotes = sp.record(
                    proposalId = multisigAdmin.data.lastProposalId,
                    signatures = [signer2_vote, signer3_vote]
                )
                multisigAdmin.aggregated_endorsement([proposalVotes]).run(sender = signer1)
                sc.verify(administrated.data.active == False)

    add_test(internal_tests = True)
    add_test(internal_tests = False)