Module multisig

# Two Level Multisig - Example for illustrative purposes only.

import smartpy as sp

# MultiSigFactory is a two level multisig factory contract
# - two level because to validate a property, we can use several groups of participants and not only one group,
# - and a factory because it can hold several such two level multisig contracts.

@sp.module
def t():
    participant: type = sp.record(hasVoted=sp.bool, weight=sp.int, id=sp.address)

    group: type = sp.record(
        weight          = sp.int,
        voters          = sp.int,
        contractWeight  = sp.int,
        thresholdWeight = sp.int,
        thresholdVoters = sp.int,
        participants    = sp.list[participant],
        ok              = sp.bool
    )

    contract: type = sp.record(
        amount            = sp.mutez,
        name              = sp.string,
        owner             = sp.address,
        thresholdGroupsOK = sp.int,
        groupsOK          = sp.int,
        thresholdWeight   = sp.int,
        weight            = sp.int,
        groups            = sp.list[group],
        ok                = sp.bool
    )

@sp.module
def main():
    class MultiSigFactory(sp.Contract):
        def __init__(self):
            self.data.multisigs = sp.cast(sp.big_map(), sp.big_map[sp.nat, t.contract])
            self.data.nbMultisigs = sp.nat(0)

        @sp.entrypoint
        def build(self, params):
            self.data.multisigs[self.data.nbMultisigs] = params.contract
            self.data.nbMultisigs += 1

        @sp.entrypoint
        def sign(self, id, contractId, contractName):
            assert id == sp.sender
            sp.cast(contractName, sp.string)
            contract = self.data.multisigs[contractId]
            assert contractName == contract.name
            sp.cast(contract.weight, sp.int)
            sp.cast(contract.groupsOK, sp.int)
            for group in contract.groups:
                for participant in group.participants:
                    if participant.id == id:
                        assert not participant.hasVoted
                        participant.hasVoted = True
                        sp.cast(group.weight, sp.int)
                        group.weight += participant.weight
                        group.voters += 1
                        if not group.ok and group.thresholdVoters <= group.voters and group.thresholdWeight <= group.weight:
                            group.ok = True
                            contract.weight += group.contractWeight
                            contract.groupsOK += 1
                            if not contract.ok and contract.thresholdGroupsOK <= contract.groupsOK and contract.thresholdWeight <= contract.weight:
                                contract.ok = True
                                self.onOK(contract)

        @sp.private(with_storage="read-write", with_operations=True)
        def onOK(self, contract):
            return ()

    # MultiSigFactoryWithPayment inherits from MultiSigFactory and adds a
    # payment functionality

    class MultiSigFactoryWithPayment(MultiSigFactory):
        def __init__(self):
            MultiSigFactory.__init__(self)

        @sp.private(with_storage="read-write", with_operations=True)
        def onOK(self, contract):
            sp.send(contract.owner, contract.amount)


def addMultiSig(c, thresholdWeight, thresholdGroupsOK):
    # tgroup = c.getStorageType().go('multisigs').go('list').go('groups').go('list')
    # tparticipant = tgroup.go('participants').go('list')
    def group(contractWeight, thresholdWeight, thresholdVoters, participants):
        participants = [sp.record(hasVoted = False, weight = weight, id = id) for (id, weight) in participants]
        return sp.record(weight          = 0,
                        voters          = 0,
                        contractWeight  = contractWeight,
                        thresholdWeight = thresholdWeight,
                        thresholdVoters = thresholdVoters,
                        participants    = participants,
                        ok              = False
        )
    p1 = sp.address("tz1NFevnqBrtcZTZTeKP2YBBjsPs9bih5i3J")
    p2 = sp.address("tz1ZRjMiF9K9n3S9AcUrTGUzR2okS7dn9KXS")
    p3 = sp.address("tz1NLJRAAwYdggijWz9EFtX5Dgs95BLfD6mP")
    g1 = group(5, 5 , 2, [(p1, 2), (p2, 8), (p3, 1)])
    g2 = group(7, 5 , 1, [(p1, 7), (p2, 8)])
    g3 = group(7, 10, 1, [(p3, 10)])
    contract = sp.record(amount            = sp.tez(0),
                         name              = "demo",
                         owner             = p1,
                         thresholdGroupsOK = thresholdGroupsOK,
                         groupsOK          = 0,
                         thresholdWeight   = thresholdWeight,
                         weight            = 0,
                         groups            = sp.list([g1, g2, g3]),
                         ok                = False)
    return c.build(contract = contract)

# Tests
@sp.add_test(name = "MultiSig")
def test():
    alice    = sp.test_account("Alice")
    bob      = sp.test_account("Rob")
    charlie  = sp.test_account("Charlie")

    scenario = sp.test_scenario([t, main])
    c1 = main.MultiSigFactory()
    scenario.h1("Multi Sig")
    scenario.h2("Contract")
    scenario.h3("Simple multisig factories")
    scenario += c1
    scenario.h2("First: define a simple multisig")
    addMultiSig(c1, thresholdWeight = 10, thresholdGroupsOK = 2)
    scenario.h2("Message execution")
    scenario.h3("A first move")
    c1.sign(id = alice.address, contractId = 0, contractName = "demo").run(sender = alice)
    c1.sign(id = bob.address, contractId = 0, contractName = "demo").run(sender = bob)

    scenario.h2("First: define a simple multi-sig")
    addMultiSig(c1, thresholdWeight = 10, thresholdGroupsOK = 3)
    scenario.h2("Message execution")
    scenario.h3("A first move")
    c1.sign(id = alice.address, contractId = 1, contractName = "demo").run(sender = alice)
    c1.sign(id = bob.address, contractId = 1, contractName = "demo").run(sender = bob)
    scenario.h4("We need a third vote")
    c1.sign(id = charlie.address, contractId = 1, contractName = "demo").run(sender = charlie)
    scenario.h4("Final state")
    scenario.show(c1.data)

    scenario.h3("Multisig factories with payments")
    c2 = main.MultiSigFactoryWithPayment()
    scenario += c2