def __init__(self,admin,endCycle,endWithdraw,token,oro): self.init(contractBuyer= sp.big_map(),contractSellar = sp.big_map(), administrator = admin,buyerSet = sp.set(),poolSet=sp.set(), validation=sp.record(cycleEnd=sp.timestamp(endCycle),withdrawTime=sp.timestamp(endWithdraw),totalSupply=sp.nat(0)), tokenContract=token,adminAccount=0,model=sp.map(),Oracle=oro)
def test(): scenario = sp.test_scenario() scenario.h1("TzWrappedFA2 - A blueprint TzWrappedFA2 implementation") scenario.table_of_contents() administrator = sp.test_account("Adiministrator") alice = sp.test_account("Alice") bob = sp.test_account("Robert") dan = sp.test_account("Dan") scenario.h2("Accounts") scenario.show([administrator, alice, bob, dan]) tzwrapped_fa2_contract = TzWrappedFA2({administrator.address:True}) scenario += tzwrapped_fa2_contract scenario.h2("Admin Calls") scenario.h3("Initialise 3 tokens") token_metadata_list = [sp.record(token_id=sp.nat(0), token_metadata=sp.map()),sp.record(token_id=sp.nat(1), token_metadata=sp.map()),sp.record(token_id=sp.nat(2), token_metadata=sp.map())] scenario += tzwrapped_fa2_contract.set_token_metadata(token_metadata_list).run(sender=administrator) scenario += tzwrapped_fa2_contract.initialise_token([sp.nat(0),sp.nat(1),sp.nat(2)]).run(sender=administrator) scenario.h2("Owner Only Calls") scenario.h3("Transferring the Ownership to the individual owners") ownerships = [sp.record(token_id=sp.nat(0), owner=alice.address),sp.record(token_id=sp.nat(1), proposed_administrator=bob.address),sp.record(token_id=sp.nat(2), owner=dan.address)] scenario.p("Not admin trying to propose new owner") scenario += tzwrapped_fa2_contract.propose_administrator(LedgerKey.make(alice.address, sp.nat(0))).run(sender=alice, valid=False) scenario.p("Not admin trying to transfer directly") scenario += tzwrapped_fa2_contract.set_administrator(sp.nat(0)).run(sender=bob, valid=False) scenario.p("Correct admin trying to transfer directly") scenario += tzwrapped_fa2_contract.set_administrator(sp.nat(0)).run(sender=administrator, valid=False) scenario.p("Correct admin trying to propose transfer") scenario += tzwrapped_fa2_contract.propose_administrator(LedgerKey.make(alice.address, sp.nat(0))).run(sender=administrator, valid=True) scenario += tzwrapped_fa2_contract.propose_administrator(LedgerKey.make(bob.address, sp.nat(1))).run(sender=administrator, valid=True) scenario += tzwrapped_fa2_contract.propose_administrator(LedgerKey.make(dan.address, sp.nat(2))).run(sender=administrator, valid=True) scenario.p("Correct admin (but not proposed) trying to transfer") scenario += tzwrapped_fa2_contract.set_administrator(sp.nat(0)).run(sender=administrator, valid=False) scenario.p("Proposed admin trying to transfer") scenario += tzwrapped_fa2_contract.set_administrator(sp.nat(0)).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.set_administrator(sp.nat(1)).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.set_administrator(sp.nat(2)).run(sender=dan, valid=True) scenario.p("Non Admin deletes rights") scenario += tzwrapped_fa2_contract.remove_administrator(LedgerKey.make(administrator.address, sp.nat(0))).run(sender=dan, valid=False) scenario += tzwrapped_fa2_contract.remove_administrator(LedgerKey.make(administrator.address, sp.nat(1))).run(sender=alice, valid=False) scenario += tzwrapped_fa2_contract.remove_administrator(LedgerKey.make(administrator.address, sp.nat(2))).run(sender=bob, valid=False) scenario.p("Admin deletes own rights") scenario += tzwrapped_fa2_contract.remove_administrator(LedgerKey.make(administrator.address, sp.nat(0))).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.remove_administrator(LedgerKey.make(administrator.address, sp.nat(1))).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.remove_administrator(LedgerKey.make(administrator.address, sp.nat(2))).run(sender=dan, valid=True) scenario.h3("Issuing") scenario.p("Correct admin but not owner trying to issue") scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(0), amount=sp.nat(100))]).run(sender=administrator, valid=False) scenario.p("Incorrect owner trying to issue (Alice is owner of 0 not 1)") scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(1), amount=sp.nat(100))]).run(sender=alice, valid=False) scenario.p("Correct owner trying to batch issue (Alice is owner of 0 not 1 and 2)") scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(0), amount=sp.nat(100)), sp.record(token_id=sp.nat(1), amount=sp.nat(100)), sp.record(token_id=sp.nat(2), amount=sp.nat(100))]).run(sender=alice, valid=False) scenario.p("Correct owners issuing tokens") scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(0), amount=sp.nat(100))]).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(1), amount=sp.nat(100))]).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(2), amount=sp.nat(100))]).run(sender=dan, valid=True) scenario.p("Correct owners issuing additional amounts of tokens") scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(0), amount=sp.nat(101))]).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(1), amount=sp.nat(101))]).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(2), amount=sp.nat(101))]).run(sender=dan, valid=True) scenario.verify(tzwrapped_fa2_contract.data.ledger[LedgerKey.make(alice.address, 0)] == 201) scenario.verify(tzwrapped_fa2_contract.data.ledger[LedgerKey.make(bob.address, 1)] == 201) scenario.verify(tzwrapped_fa2_contract.data.ledger[LedgerKey.make(dan.address, 2)] == 201) scenario.h3("Setting Redeem Address") scenario.p("Correct admin but not owner trying to set redeem address") scenario += tzwrapped_fa2_contract.set_redeem_addresses([sp.record(token_id=sp.nat(0), address=alice.address)]).run(sender=administrator, valid=False) scenario.p("Correct owners setting redeem addresses") scenario += tzwrapped_fa2_contract.set_redeem_addresses([sp.record(token_id=sp.nat(0), address=alice.address)]).run(sender=alice) scenario += tzwrapped_fa2_contract.set_redeem_addresses([sp.record(token_id=sp.nat(1), address=bob.address)]).run(sender=bob) scenario += tzwrapped_fa2_contract.set_redeem_addresses([sp.record(token_id=sp.nat(2), address=dan.address)]).run(sender=dan) scenario.p("Incorrect owner trying to burn (Alice is owner of 0 not 1)") scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(1), amount=sp.nat(100))]).run(sender=alice, valid=False) scenario.p("Correct owner trying to batch burn (Alice is owner of 0 not 1 and 2)") scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(0), amount=sp.nat(100)), sp.record(token_id=sp.nat(1), amount=sp.nat(100)), sp.record(token_id=sp.nat(1), amount=sp.nat(100))]).run(sender=alice, valid=False) scenario.h3("Redemption") scenario.p("Correct admin but not owner trying to burn") scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(0), amount=sp.nat(100))]).run(sender=administrator, valid=False) scenario.p("Incorrect owner trying to burn (Alice is owner of 0 not 1)") scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(1), amount=sp.nat(100))]).run(sender=alice, valid=False) scenario.p("Correct owner trying to batch burn (Alice is owner of 0 not 1 and 2)") scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(0), amount=sp.nat(100)), sp.record(token_id=sp.nat(1), amount=sp.nat(100)), sp.record(token_id=sp.nat(1), amount=sp.nat(100))]).run(sender=alice, valid=False) scenario.p("Correct owners burning tokens") scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(0), amount=sp.nat(100))]).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(1), amount=sp.nat(100))]).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(2), amount=sp.nat(100))]).run(sender=dan, valid=True) scenario.verify(tzwrapped_fa2_contract.data.ledger[LedgerKey.make(alice.address, 0)] == 101) scenario.verify(tzwrapped_fa2_contract.data.ledger[LedgerKey.make(bob.address, 1)] == 101) scenario.verify(tzwrapped_fa2_contract.data.ledger[LedgerKey.make(dan.address, 2)] == 101) scenario.p("Cannot burn more than owner has") scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(0), amount=sp.nat(201))]).run(sender=alice, valid=False) scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(1), amount=sp.nat(201))]).run(sender=bob, valid=False) scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(2), amount=sp.nat(201))]).run(sender=dan, valid=False) scenario.p("Correct owners burning additional amounts of tokens") scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(0), amount=sp.nat(101))]).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(1), amount=sp.nat(101))]).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.burn([sp.record(token_id=sp.nat(2), amount=sp.nat(101))]).run(sender=dan, valid=True) scenario.verify(~tzwrapped_fa2_contract.data.ledger.contains(LedgerKey.make(alice.address, 0))) scenario.verify(~tzwrapped_fa2_contract.data.ledger.contains(LedgerKey.make(bob.address, 1))) scenario.verify(~tzwrapped_fa2_contract.data.ledger.contains(LedgerKey.make(dan.address, 2))) scenario.h3("Reassign") scenario.p("Bootstrapping by issuing some tokens") scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(0), amount=sp.nat(50))]).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(1), amount=sp.nat(47))]).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.mint([sp.record(token_id=sp.nat(2), amount=sp.nat(39))]).run(sender=dan, valid=True) scenario.h3("Pause") scenario.p("Correct admin but not owner trying to pause") scenario += tzwrapped_fa2_contract.pause([sp.nat(0)]).run(sender=administrator, valid=False) scenario.p("Incorrect owner trying to pause (Alice is owner of 0 not 1)") scenario += tzwrapped_fa2_contract.pause([sp.nat(1)]).run(sender=alice, valid=False) scenario.p("Correct owner trying to batch pause (Alice is owner of 0 not 1 and 2)") scenario += tzwrapped_fa2_contract.pause([sp.nat(0), sp.nat(1), sp.nat(2)]).run(sender=alice, valid=False) scenario.p("Correct owners pauseing tokens") scenario += tzwrapped_fa2_contract.pause([sp.nat(1)]).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.pause([sp.nat(2)]).run(sender=dan, valid=True) scenario.h3("Unpause") scenario.p("Correct admin but not owner trying to unpause") scenario += tzwrapped_fa2_contract.unpause([sp.nat(0)]).run(sender=administrator, valid=False) scenario.p("Incorrect owner trying to unpause (Alice is owner of 0 not 1)") scenario += tzwrapped_fa2_contract.unpause([sp.nat(1)]).run(sender=alice, valid=False) scenario.p("Correct owner trying to batch unpause (Alice is owner of 0 not 1 and 2)") scenario += tzwrapped_fa2_contract.unpause([sp.nat(0), sp.nat(1), sp.nat(2)]).run(sender=alice, valid=False) scenario.p("Correct owners unpauseing tokens") scenario += tzwrapped_fa2_contract.unpause([sp.nat(1)]).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.unpause([sp.nat(2)]).run(sender=dan, valid=True) scenario.h2("Token Holder Calls") scenario.h3("Transfer") scenario.p("Holder with no balance tries transfer") scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=bob.address, txs=[sp.record(to_=dan.address, token_id=sp.nat(0), amount=sp.nat(1))])]).run(sender=bob, valid=False) scenario.p("Admin with no balance tries transfer") scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=administrator.address, txs=[sp.record(to_=dan.address, token_id=sp.nat(0), amount=sp.nat(1))])]).run(sender=administrator, valid=False) scenario.p("Admin tries transfer of third parties balance") scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=alice.address, txs=[sp.record(to_=dan.address, token_id=sp.nat(0), amount=sp.nat(1))])]).run(sender=administrator, valid=False) scenario.p("Owner performs initial transfer of own balance") scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=alice.address, txs=[sp.record(to_=dan.address, token_id=sp.nat(0), amount=sp.nat(10))])]).run(sender=alice, valid=True) scenario.p("Owner tries transfer of third party balance") scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=dan.address, txs=[sp.record(to_=bob.address, token_id=sp.nat(0), amount=sp.nat(1))])]).run(sender=alice, valid=False) scenario.p("Holder transfers own balance") scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=dan.address, txs=[sp.record(to_=bob.address, token_id=sp.nat(0), amount=sp.nat(1))])]).run(sender=dan, valid=True) scenario.p("Holder transfers too much") scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=dan.address, txs=[sp.record(to_=bob.address, token_id=sp.nat(0), amount=sp.nat(11))])]).run(sender=dan, valid=False) scenario.h3("Pause/Unpause") scenario.p("Holder transfers too much") scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=dan.address, txs=[sp.record(to_=bob.address, token_id=sp.nat(0), amount=sp.nat(11))])]).run(sender=dan, valid=False) scenario.p("Holder transfers paused token") scenario += tzwrapped_fa2_contract.pause([sp.nat(0)]).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.pause([sp.nat(1)]).run(sender=bob, valid=True) scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=dan.address, txs=[sp.record(to_=bob.address, token_id=sp.nat(0), amount=sp.nat(1))])]).run(sender=dan, valid=False) scenario.p("Holder transfers resumed token") scenario += tzwrapped_fa2_contract.unpause([sp.nat(0)]).run(sender=alice, valid=True) scenario += tzwrapped_fa2_contract.transfer([sp.record(from_=dan.address, txs=[sp.record(to_=bob.address, token_id=sp.nat(0), amount=sp.nat(1))])]).run(sender=dan, valid=True)
def __init__(self, admin): self.init(xtzPrice = sp.nat(0), keysset = sp.set([admin]) , owner = admin,StrikePrice=sp.map())
def test(): scenario = sp.test_scenario() # The multisig address. multisigAddress = sp.address("tz1hoverof3f2F8NAavUyTjbFBstZXTqnUMS") # And there's a DAO daoAddress = sp.address("KT1Hkg5qeNhfwpKW4fXvq7HGZB9z2EnmCCA9") # A box contract is controlled by the MSig. Just like Kolibri contracts today. box = Box(governorAddress=multisigAddress) scenario += box # A break glass gets deployed which maps the dao and break glass to the store. breakGlass = BreakGlass( daoAddress=daoAddress, multisigAddress=multisigAddress, targetAddress=box.address, ) scenario += breakGlass # The multisig gives up control to the break glass. scenario += box.setGovernorContract( breakGlass.address).run(sender=multisigAddress) # THEN permissions are set correctly scenario.verify(box.data.governorAddress == breakGlass.address) scenario.verify(breakGlass.data.targetAddress == box.address) scenario.verify(breakGlass.data.multisigAddress == multisigAddress) scenario.verify(breakGlass.data.daoAddress == daoAddress) # A lambda is crafted to update the store address. newValue = sp.nat(3) def updateLambda(unitParam): sp.set_type(unitParam, sp.TUnit) storeContractHandle = sp.contract(sp.TNat, box.address, 'update').open_some() sp.result([ sp.transfer_operation(newValue, sp.mutez(0), storeContractHandle) ]) # AND the lambda is executed in the break glass by the dao. scenario += breakGlass.runLambda(updateLambda).run(sender=daoAddress) # Then things go as planned and the value in the box is updated scenario.verify(box.data.value == newValue) # Of course, if we try to update the box directly, that fails. scenario += box.update(sp.nat(4)).run( sender=multisigAddress, valid=False, ) # Oh no, the DAO is unstable. Let's break glass to get back control scenario += breakGlass.breakGlass(multisigAddress).run( sender=multisigAddress) # THEN the permissions are updated scenario.verify(box.data.governorAddress == multisigAddress) # AND the multisig can update the value. multisigValue = sp.nat(5) scenario += box.update(multisigValue).run(sender=multisigAddress, ) scenario.verify(box.data.value == multisigValue) # And the DAO has no perms. scenario += breakGlass.runLambda(updateLambda).run( sender=daoAddress, valid=False, )
def test(): obj = StakePool(sp.address("tz1-Admin")) scenario = sp.test_scenario() scenario += obj scenario += obj.depositXTZ().run(sender = sp.address("tz1-Admin") , amount = sp.tez(1000)) scenario += obj.recoverXTZ(amount = sp.tez(500)).run(sender = sp.address("tz1-Admin")) # Cycle - 63 Ongoing # Betting Intitation 63 -> 65 #scenario += obj.updatePrice(price = sp.int(4000)).run(level = 129661 ,sender = sp.address("tz1-Admin")) scenario += obj.fetchPriceAndUpdateCycle(asset = "XTZ-USD" , harbingerContractAddress = sp.address("KT1-Normalizer-Harbinger") , targetAddress = sp.address("KT1-SELF")).run(sender = sp.address("tz1-Admin")) scenario += obj.getResponseFromHarbinger(("XTZ-USD" , (sp.timestamp(0) , sp.nat(4000000)))).run(level = 129661 ,sender = sp.address("KT1-Normalizer-Harbinger") ,source= sp.address("tz1-Admin")) #Placing Bet scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(250)).run(sender = sp.address("tz1-Bob") , amount = sp.tez(2) , level = 129668) scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(250)).run(sender = sp.address("tz1-Mark") , amount = sp.tez(2) , level = 129667) scenario += obj.placeBet(top = sp.int(-250) , bottom = sp.int(0)).run(sender = sp.address("tz1-Alice") , amount = sp.tez(2) , level = 129670) scenario += obj.placeBet(top = sp.int(250) , bottom = sp.int(500)).run(sender = sp.address("tz1-Joe") , amount = sp.tez(3) , level = 129671) scenario += obj.placeBet(top = sp.int(250) , bottom = sp.int(500)).run(sender = sp.address("tz1-John") , amount = sp.tez(4) , level = 129672) scenario += obj.placeBet(top = sp.int(1000) , bottom = sp.int(1000)).run(sender = sp.address("tz1-Elan") , amount = sp.tez(4) , level = 129672) # Cycle - 64 Ongoing # Betting Intitation 64 -> 66 # scenario += obj.updatePrice(price = sp.int(3900)).run(level = 131720 , sender = sp.address("tz1-Admin")) scenario += obj.fetchPriceAndUpdateCycle(asset = "XTZ-USD" , harbingerContractAddress = sp.address("KT1-Normalizer-Harbinger") , targetAddress = sp.address("KT1-SELF")).run(sender = sp.address("tz1-Admin")) scenario += obj.getResponseFromHarbinger(("XTZ-USD" , (sp.timestamp(0) , sp.nat(3900000)))).run(level = 131720 ,sender = sp.address("KT1-Normalizer-Harbinger") ,source= sp.address("tz1-Admin")) #Placing Bet scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(250)).run(sender = sp.address("tz1-Bob") , amount = sp.tez(4) , level = 131721) scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(250)).run(sender = sp.address("tz1-Mark") , amount = sp.tez(3) , level = 131722) scenario += obj.placeBet(top = sp.int(-250) , bottom = sp.int(0)).run(sender = sp.address("tz1-Alice") , amount = sp.tez(1) , level = 131723) scenario += obj.placeBet(top = sp.int(250) , bottom = sp.int(500)).run(sender = sp.address("tz1-Joe") , amount = sp.tez(6) , level = 131724) scenario += obj.placeBet(top = sp.int(-750) , bottom = sp.int(-500)).run(sender = sp.address("tz1-John") , amount = sp.tez(9) , level = 131725) scenario += obj.placeBet(top = sp.int(1000) , bottom = sp.int(1000)).run(sender = sp.address("tz1-Elan") , amount = sp.tez(5) , level = 131726) # Cycle - 65 Ongoing # Betting Intitation 65 -> 67 #scenario += obj.updatePrice(price = sp.int(3900)).run(level = 133220 , sender = sp.address("tz1-Admin")) scenario += obj.fetchPriceAndUpdateCycle(asset = "XTZ-USD" , harbingerContractAddress = sp.address("KT1-Normalizer-Harbinger") , targetAddress = sp.address("KT1-SELF")).run(sender = sp.address("tz1-Admin")) scenario += obj.getResponseFromHarbinger(("XTZ-USD" , (sp.timestamp(0) , sp.nat(3900000)))).run(level = 133220 ,sender = sp.address("KT1-Normalizer-Harbinger") ,source= sp.address("tz1-Admin")) #Placing Bet scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(250)).run(sender = sp.address("tz1-Bob") , amount = sp.tez(7) , level = 133221) scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(250)).run(sender = sp.address("tz1-Mark") , amount = sp.tez(6) , level = 133222) scenario += obj.placeBet(top = sp.int(-250) , bottom = sp.int(0)).run(sender = sp.address("tz1-Alice") , amount = sp.tez(5) , level = 133223) scenario += obj.placeBet(top = sp.int(250) , bottom = sp.int(500)).run(sender = sp.address("tz1-Joe") , amount = sp.tez(8) , level = 133224) scenario += obj.placeBet(top = sp.int(1000) , bottom = sp.int(1000)).run(sender = sp.address("tz1-John") , amount = sp.tez(7) , level = 133225) scenario += obj.placeBet(top = sp.int(1000) , bottom = sp.int(1000)).run(sender = sp.address("tz1-Elan") , amount = sp.tez(9) , level = 133226) # Cycle - 66 Ongoing # Changing prediction ranges scenario += obj.changeBetRange(step=300,end=1200).run(sender=sp.address("tz1-Admin")) # Betting Intitation 66 -> 68 # Concluding 65 #scenario += obj.updatePrice(price = sp.int(4050)).run(level = 135268,sender = sp.address("tz1-Admin")) scenario += obj.fetchPriceAndUpdateCycle(asset = "XTZ-USD" , harbingerContractAddress = sp.address("KT1-Normalizer-Harbinger") , targetAddress = sp.address("KT1-SELF")).run(sender = sp.address("tz1-Admin")) scenario += obj.getResponseFromHarbinger(("XTZ-USD" , (sp.timestamp(0) , sp.nat(4050000)))).run(level = 135268 ,sender = sp.address("KT1-Normalizer-Harbinger") ,source= sp.address("tz1-Admin")) #Placing Bet scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(300)).run(sender = sp.address("tz1-Bob") , amount = sp.tez(7) , level = 135270) scenario += obj.placeBet(top = sp.int(300) , bottom = sp.int(600)).run(sender = sp.address("tz1-Mark") , amount = sp.tez(6) , level = 135271) scenario += obj.placeBet(top = sp.int(-600) , bottom = sp.int(-300)).run(sender = sp.address("tz1-Alice") , amount = sp.tez(5) , level = 135272) scenario += obj.placeBet(top = sp.int(-1200) , bottom = sp.int(-1200)).run(sender = sp.address("tz1-Joe") , amount = sp.tez(8) , level = 135273) scenario += obj.placeBet(top = sp.int(1200) , bottom = sp.int(1200)).run(sender = sp.address("tz1-John") , amount = sp.tez(7) , level = 135274) scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(300)).run(sender = sp.address("tz1-Elan") , amount = sp.tez(9) , level = 135275) # Withdrawals of 65 scenario += obj.withdrawAmount(cycle = sp.int(65)).run(sender = sp.address("tz1-Alice")) scenario += obj.withdrawAmount(cycle = sp.int(65)).run(sender = sp.address("tz1-Bob")) scenario += obj.withdrawAmount(cycle = sp.int(65)).run(sender = sp.address("tz1-Joe")) scenario += obj.withdrawAmount(cycle = sp.int(65)).run(sender = sp.address("tz1-John")) scenario += obj.withdrawAmount(cycle = sp.int(65)).run(sender = sp.address("tz1-Mark")) scenario += obj.withdrawAmount(cycle = sp.int(65)).run(sender = sp.address("tz1-Elan")) # Cycle - 67 Ongoing # Changing prediction ranges scenario += obj.changeBetRange(step=400,end=2000).run(sender=sp.address("tz1-Admin")) # Betting Intitation 66 -> 69 # Concluding 66 #scenario += obj.updatePrice(price = sp.int(3700)).run(level = 137316,sender = sp.address("tz1-Admin")) scenario += obj.fetchPriceAndUpdateCycle(asset = "XTZ-USD" , harbingerContractAddress = sp.address("KT1-Normalizer-Harbinger") , targetAddress = sp.address("KT1-SELF")).run(sender = sp.address("tz1-Admin")) scenario += obj.getResponseFromHarbinger(("XTZ-USD" , (sp.timestamp(0) , sp.nat(3700000)))).run(level = 137316 ,sender = sp.address("KT1-Normalizer-Harbinger") ,source= sp.address("tz1-Admin")) #Placing Bet scenario += obj.placeBet(top = sp.int(0) , bottom = sp.int(400)).run(sender = sp.address("tz1-Bob") , amount = sp.tez(7) , level = 137320) scenario += obj.placeBet(top = sp.int(800) , bottom = sp.int(1200)).run(sender = sp.address("tz1-Mark") , amount = sp.tez(6) , level = 137321) scenario += obj.placeBet(top = sp.int(-800) , bottom = sp.int(-400)).run(sender = sp.address("tz1-Alice") , amount = sp.tez(5) , level = 137322) scenario += obj.placeBet(top = sp.int(-1200) , bottom = sp.int(-800)).run(sender = sp.address("tz1-Joe") , amount = sp.tez(8) , level = 137323) scenario += obj.placeBet(top = sp.int(2000) , bottom = sp.int(2000)).run(sender = sp.address("tz1-John") , amount = sp.tez(7) , level = 137324) scenario += obj.placeBet(top = sp.int(800) , bottom = sp.int(1200)).run(sender = sp.address("tz1-Elan") , amount = sp.tez(9) , level = 137325) # Betting not allowed through contract scenario += obj.placeBet(top = sp.int(800) , bottom = sp.int(1200)).run(source = sp.address("KT1-Jane") , sender = sp.address("tz1-Jane") , amount = sp.tez(9) , level = 137326 ,valid=False) # Withdrawals of 66 scenario += obj.withdrawAmount(cycle = sp.int(66)).run(sender = sp.address("tz1-Alice")) scenario += obj.withdrawAmount(cycle = sp.int(66)).run(sender = sp.address("tz1-Bob")) scenario += obj.withdrawAmount(cycle = sp.int(66)).run(sender = sp.address("tz1-Joe")) scenario += obj.withdrawAmount(cycle = sp.int(66)).run(sender = sp.address("tz1-John")) scenario += obj.withdrawAmount(cycle = sp.int(66)).run(sender = sp.address("tz1-Mark")) scenario += obj.withdrawAmount(cycle = sp.int(66)).run(sender = sp.address("tz1-Elan")) # Cycle - 68 Ongoing # Betting Intitation 68 -> 70 # Concluding 67 #scenario += obj.updatePrice(price = sp.int(5000)).run(level = 140264,sender = sp.address("tz1-Admin")) scenario += obj.fetchPriceAndUpdateCycle(asset = "XTZ-USD" , harbingerContractAddress = sp.address("KT1-Normalizer-Harbinger") , targetAddress = sp.address("KT1-SELF")).run(sender = sp.address("tz1-Admin")) scenario += obj.getResponseFromHarbinger(("XTZ-USD" , (sp.timestamp(0) , sp.nat(5000000)))).run(level = 140264 ,sender = sp.address("KT1-Normalizer-Harbinger") ,source= sp.address("tz1-Admin")) # Withdrawals of 67 scenario += obj.withdrawAmount(cycle = sp.int(67)).run(sender = sp.address("tz1-Alice")) scenario += obj.withdrawAmount(cycle = sp.int(67)).run(sender = sp.address("tz1-Bob")) scenario += obj.withdrawAmount(cycle = sp.int(67)).run(sender = sp.address("tz1-Joe")) scenario += obj.withdrawAmount(cycle = sp.int(67)).run(sender = sp.address("tz1-John")) scenario += obj.withdrawAmount(cycle = sp.int(67)).run(sender = sp.address("tz1-Mark")) scenario += obj.withdrawAmount(cycle = sp.int(67)).run(sender = sp.address("tz1-Elan")) # Cycle - 69 Ongoing # Betting Intitation 69 -> 71 # Concluding 68 #scenario += obj.updatePrice(price = sp.int(4233)).run(level = 141412,sender = sp.address("tz1-Admin")) scenario += obj.fetchPriceAndUpdateCycle(asset = "XTZ-USD" , harbingerContractAddress = sp.address("KT1-Normalizer-Harbinger") , targetAddress = sp.address("KT1-SELF")).run(sender = sp.address("tz1-Admin")) scenario += obj.getResponseFromHarbinger(("XTZ-USD" , (sp.timestamp(0) , sp.nat(4233000)))).run(level = 141412 ,sender = sp.address("KT1-Normalizer-Harbinger") ,source= sp.address("tz1-Admin")) # Withdrawals of 68 scenario += obj.withdrawAmount(cycle = sp.int(68)).run(sender = sp.address("tz1-Alice")) scenario += obj.withdrawAmount(cycle = sp.int(68)).run(sender = sp.address("tz1-Bob")) scenario += obj.withdrawAmount(cycle = sp.int(68)).run(sender = sp.address("tz1-Joe")) scenario += obj.withdrawAmount(cycle = sp.int(68)).run(sender = sp.address("tz1-John")) scenario += obj.withdrawAmount(cycle = sp.int(68)).run(sender = sp.address("tz1-Mark")) scenario += obj.withdrawAmount(cycle = sp.int(68)).run(sender = sp.address("tz1-Elan")) # Duplicate Withdrawal scenario += obj.withdrawAmount(cycle = sp.int(68)).run(sender = sp.address("tz1-Elan") , valid = False) # Cycle - 70 Ongoing # Betting Intitation 70 -> 72 # Concluding 69 #scenario += obj.updatePrice(price = sp.int(4070)).run(level = 143460,sender = sp.address("tz1-Admin")) scenario += obj.fetchPriceAndUpdateCycle(asset = "XTZ-USD" , harbingerContractAddress = sp.address("KT1-Normalizer-Harbinger") , targetAddress = sp.address("KT1-SELF")).run(sender = sp.address("tz1-Admin")) scenario += obj.getResponseFromHarbinger(("XTZ-USD" , (sp.timestamp(0) , sp.nat(4070000)))).run(level = 143460 ,sender = sp.address("KT1-Normalizer-Harbinger") ,source= sp.address("tz1-Admin")) # Withdrawals of 69 scenario += obj.withdrawAmount(cycle = sp.int(69)).run(sender = sp.address("tz1-Alice")) scenario += obj.withdrawAmount(cycle = sp.int(69)).run(sender = sp.address("tz1-Bob")) scenario += obj.withdrawAmount(cycle = sp.int(69)).run(sender = sp.address("tz1-Joe")) scenario += obj.withdrawAmount(cycle = sp.int(69)).run(sender = sp.address("tz1-John")) scenario += obj.withdrawAmount(cycle = sp.int(69)).run(sender = sp.address("tz1-Mark")) scenario += obj.withdrawAmount(cycle = sp.int(69)).run(sender = sp.address("tz1-Elan")) # Admin Only Funstions Test scenario += obj.changeBettingPauseState().run(sender=sp.address("tz1-Admin")) scenario += obj.changeBettingPauseState().run(sender=sp.address("tz1-Admin")) scenario += obj.changeWithdrawalsPauseState().run(sender = sp.address("tz1-Admin")) scenario += obj.changeWithdrawalsPauseState().run(sender = sp.address("tz1-Admin")) scenario += obj.addAdmin(address = sp.address("tz1-Admin-2")).run(sender=sp.address("tz1-Admin")) scenario += obj.addAdmin(address = sp.address("tz1-Admin-3")).run(sender=sp.address("tz1-Admin")) scenario += obj.removeAdmin(address = sp.address("tz1-Admin-3")).run(sender=sp.address("tz1-Admin")) scenario += obj.changeROI(numerator = 400 , denominator = 100000).run(sender=sp.address("tz1-Admin")) scenario += obj.changeROI(numerator = 588 , denominator = 100000).run(sender=sp.address("tz1-Admin")) scenario += obj.changeBetRange(step=300,end=1200).run(sender=sp.address("tz1-Admin")) scenario += obj.changeBetRange(step=250,end=1000).run(sender=sp.address("tz1-Admin")) scenario += obj.changeBlocksPerCycle(blocksPerCycle = sp.int(4096)).run(sender=sp.address("tz1-Admin")) scenario += obj.changeBlocksPerCycle(blocksPerCycle = sp.int(2048)).run(sender=sp.address("tz1-Admin")) scenario += obj.changeBetLimit(betLimit = sp.tez(100)).run(sender=sp.address("tz1-Admin")) scenario += obj.delegate(sp.some(sp.key_hash("tz1-Baker"))).run(sender=sp.address("tz1-Admin"))
def test(): scenario = sp.test_scenario() scenario.h1("Auction House") scenario.table_of_contents() admin = sp.test_account("Administrator") alice = sp.test_account("Alice") bob = sp.test_account("Robert") dan = sp.test_account("Dan") minter = sp.test_account("Minter") # Let's display the accounts: scenario.h2("Accounts") scenario.show([admin, alice, bob, dan, minter]) auction_house = AuctionHouse() scenario += auction_house scenario.h2("AcuteArtFA2") fa2 = AcuteArtFA2(auction_house.address, minter.address) scenario += fa2 scenario.h2("Initial minting") scenario.p("Minter mints token 0 with no royalty") scenario += fa2.mint(token_id = 0, royalty = sp.none, metadata = sp.bytes_of_string('ipfs://foo')).run(sender = minter.address) scenario.p("Alice fails to mint token 1") scenario += fa2.mint(token_id = 1, royalty = sp.none, metadata = sp.bytes_of_string('ipfs://foo')).run(sender = alice.address, valid=False) scenario.p("Minter fails to re-mint token 0") scenario += fa2.mint(token_id = 0, royalty = sp.none, metadata = sp.bytes_of_string('ipfs://foo')).run(sender = minter.address, valid=False) scenario.p("Minter sends token to Bob") scenario += fa2.transfer([BatchTransfer.item(minter.address, [sp.record(to_=bob.address, token_id=0, amount=1)])]).run(sender=minter, valid=True) scenario.p("Bob updates operators") scenario += fa2.update_operators([sp.variant('add_operator', sp.record(owner=bob.address,operator=auction_house.address,token_id=sp.nat(0)))]).run(sender=bob) scenario.h2("User Auction") scenario.p("Bob creates auction") auction_id = sp.nat(0) # we can reuse 0 scenario += auction_house.create_auction(sp.record(auction_id=auction_id, token_address=fa2.address, token_id=sp.nat(0), token_amount=sp.nat(1), end_timestamp=sp.timestamp(60*60), bid_amount=sp.mutez(100000))).run(sender=bob, now=sp.timestamp(0)) scenario.p("Bob tries to withdraw") scenario += auction_house.withdraw(0).run(sender=bob, amount=sp.mutez(0), now=sp.timestamp(0), valid=False) scenario.p("Alice bids") scenario += auction_house.bid(0).run(sender=alice,amount=sp.mutez(200000), now=sp.timestamp(0)) scenario.p("Dan bids") scenario += auction_house.bid(0).run(sender=dan,amount=sp.mutez(300000), now=sp.timestamp(1)) scenario.p("Alice rebids") scenario += auction_house.bid(0).run(sender=alice,amount=sp.mutez(400000), now=sp.timestamp(2)) scenario.p("Bob tries to withdraw") scenario += auction_house.withdraw(0).run(sender=bob, amount=sp.mutez(0), now=sp.timestamp(60*60), valid=False) scenario.p("Dan bids") scenario += auction_house.bid(0).run(sender=dan,amount=sp.mutez(500000), now=sp.timestamp(60*60-5)) scenario.p("Alice rebids") scenario += auction_house.bid(0).run(sender=alice,amount=sp.mutez(600000), now=sp.timestamp(60*60+5*60-6)) scenario.p("Alice withdraws") scenario += auction_house.withdraw(0).run(sender=alice, amount=sp.mutez(0), now=sp.timestamp(60*60+5*60-6+5*60+1)) scenario.h2("Self-Withdraw") scenario.p("Alice creates auction") auction_id = sp.nat(0) # we can reuse 0 scenario += fa2.update_operators([sp.variant('add_operator', sp.record(owner=alice.address,operator=auction_house.address,token_id=sp.nat(0)))]).run(sender=alice) scenario += auction_house.create_auction(sp.record(auction_id=auction_id, token_address=fa2.address, token_id=sp.nat(0), token_amount=sp.nat(1), end_timestamp=sp.timestamp(60*60), bid_amount=sp.mutez(100000))).run(sender=alice, now=sp.timestamp(0)) scenario.h2("Transfers") scenario.p("Bob cannot transfer alice's token") auction_id = sp.nat(0) # we can reuse 0 scenario += fa2.transfer([BatchTransfer.item(alice.address, [sp.record(to_=bob.address, token_id=0, amount=1)])]).run(sender=bob, valid=False) scenario.p("Alice cannot transfer own token") auction_id = sp.nat(0) # we can reuse 0 scenario += fa2.transfer([BatchTransfer.item(alice.address, [sp.record(to_=bob.address, token_id=0, amount=1)])]).run(sender=alice, valid=False) scenario.p("Bob bids") scenario += auction_house.bid(0).run(sender=bob, amount=sp.mutez(100000000), now=sp.timestamp(60)) scenario.p("Bob withdraws") scenario += auction_house.withdraw(0).run(sender=bob, now=sp.timestamp(120*60)) scenario.p("Auction house cannot transfer Bob's token before allowance") scenario += fa2.transfer([BatchTransfer.item(bob.address, [sp.record(to_=alice.address, token_id=0, amount=1)])]).run(sender=auction_house.address, valid=False) # scenario.show(fa2.data.ledger[LedgerKey.make(owner = auction_house.address, token_id = 0)]) scenario.p("Auction house can transfer Bob's token after allowance") scenario += fa2.update_operators([sp.variant('add_operator', sp.record(owner=bob.address,operator=auction_house.address,token_id=0))]).run(sender=bob) scenario += fa2.transfer([BatchTransfer.item(bob.address, [sp.record(to_=alice.address, token_id=0, amount=1)])]).run(sender=auction_house.address) scenario.p("Bob cannot transfer more token") auction_id = sp.nat(0) # we can reuse 0 scenario += fa2.transfer([BatchTransfer.item(bob.address, [sp.record(to_=bob.address, token_id=0, amount=2)])]).run(sender=bob, valid=False) scenario.p("Bob cannot transfer from non balance address") auction_id = sp.nat(0) # we can reuse 0 scenario += fa2.transfer([BatchTransfer.item(alice.address, [sp.record(to_=dan.address, token_id=0, amount=1)])]).run(sender=bob, valid=False) scenario.p("Alice can transfer as owner") auction_id = sp.nat(0) # we can reuse 0 scenario += fa2.transfer([BatchTransfer.item(alice.address, [sp.record(to_=dan.address, token_id=0, amount=1)])]).run(sender=alice) scenario.h2("Royalties Mechanics") auction_id = sp.nat(1) fraction = sp.nat(215000000) # 215000000/2**32 ~= 5% token_id = sp.nat(10) scenario.p("Minter mints token 10 with royalty") scenario += fa2.mint(token_id = token_id, royalty = sp.some(sp.record(recipient=minter.address, fraction=fraction)), metadata = sp.bytes_of_string('ipfs://foo')).run(sender = minter.address) scenario.p("Minter fails to send token to Bob") scenario += fa2.transfer([BatchTransfer.item(minter.address, [sp.record(to_=bob.address, token_id=token_id, amount=1)])]).run(sender=minter, valid=False) scenario.p("Minter updates operators") scenario += fa2.update_operators([sp.variant('add_operator', sp.record(owner=minter.address,operator=auction_house.address,token_id=token_id))]).run(sender=minter) scenario.p("Minter creates auction") scenario += auction_house.create_auction(sp.record(auction_id=auction_id, token_address=fa2.address, token_id=token_id, token_amount=sp.nat(1), end_timestamp=sp.timestamp(60*60), bid_amount=sp.mutez(100000))).run(sender=minter, now=sp.timestamp(0)) scenario.p("No one has bid, no royalty expected...") scenario += auction_house.withdraw(auction_id).run(sender=minter, now=sp.timestamp(60*60+1)) scenario.verify(~auction_house.data.accumulated_royalties.contains(minter.address)) scenario.p("Minter updates operators") scenario += fa2.update_operators([sp.variant('add_operator', sp.record(owner=minter.address,operator=auction_house.address,token_id=token_id))]).run(sender=minter) scenario.p("Minter creates new auction") scenario += auction_house.create_auction(sp.record(auction_id=auction_id, token_address=fa2.address, token_id=token_id, token_amount=sp.nat(1), end_timestamp=sp.timestamp(60*60), bid_amount=sp.mutez(100000))).run(sender=minter, now=sp.timestamp(0)) scenario += auction_house.bid(auction_id).run(sender=alice,amount=sp.tez(100), now=sp.timestamp(0)) scenario.p("Now we have a bid, we expect royalty") scenario += auction_house.withdraw(auction_id).run(sender=minter, now=sp.timestamp(60*60+1)) scenario.verify(auction_house.data.accumulated_royalties.contains(minter.address)) scenario.verify_equal(auction_house.data.accumulated_royalties[minter.address],sp.mutez(5005858)) scenario.p("Only minter can collect royalties") scenario += auction_house.collect_royalties(bob.address).run(sender=bob, valid=False) scenario += auction_house.collect_royalties(minter.address).run(sender=minter, valid=True) scenario.verify(~auction_house.data.accumulated_royalties.contains(minter.address)) scenario.p("Only royalty recipient can update _own_ recipient") scenario += auction_house.update_royalty_recipient(sp.record(fa2_address=fa2.address, new_recipient=bob.address, token_id=token_id)).run(sender=bob, valid=False) scenario += auction_house.update_royalty_recipient(sp.record(fa2_address=fa2.address, new_recipient=bob.address, token_id=sp.nat(0))).run(sender=bob, valid=False) scenario += auction_house.update_royalty_recipient(sp.record(fa2_address=fa2.address, new_recipient=bob.address, token_id=sp.nat(0))).run(sender=minter, valid=False) scenario += auction_house.update_royalty_recipient(sp.record(fa2_address=fa2.address, new_recipient=bob.address, token_id=token_id)).run(sender=minter, valid=True) scenario += auction_house.update_royalty_recipient(sp.record(fa2_address=fa2.address, new_recipient=alice.address, token_id=token_id)).run(sender=minter, valid=False)
def crzy(self, params): sp.verify (sp.amount >= sp.tez(5)) sp.verify (sp.tez(sp.nat(params)) == sp.amount)
from_user = self.ledger_key.make(sp.sender, params.token_id) to_user = self.ledger_key.make(highest_bidder.value.bidder, params.token_id) self.data.ledger[from_user].balance = sp.as_nat( self.data.ledger[from_user].balance - params.nft_amount) sp.if self.data.ledger.contains(to_user): self.data.ledger[to_user].balance += params.nft_amount sp.else: self.data.ledger[to_user] = FA2.Ledger_value.make(params.nft_amount) # transfer bid amount to seller # take out x percentage and send it to admin account # 10% commission commission = sp.split_tokens(highest_bidder.value.bid_value, sp.nat(10), sp.nat(100)) # Transfer xtz to the seller sp.send(sp.sender, highest_bidder.value.bid_value - commission) # Transfer commission to the admin sp.send(self.data.administrator, commission) # return the xtz amount to the rest of the bidders if any sp.for bidder in self.data.bid[params.token_id]: sp.if bidder.bidder != highest_bidder.value.bidder: sp.send(bidder.bidder, bidder.bid_value) del self.data.offer[params.token_id] del self.data.bid[params.token_id]
def test(): admin = sp.test_account("Administrator") alice = sp.test_account("Alice") bob = sp.test_account("Bob") init_eth = "0x91f79893E7B923410Ef1aEba6a67c6fab0sfsdgffd" hashSecret = sp.sha256(sp.sha256(sp.bytes( "0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a"))) token_metadata = { "decimals" : "18", # Mandatory by the spec "name" : "My Great Token", # Recommended "symbol" : "MGT", # Recommended # Extra fields "icon" : 'https://smartpy.io/static/img/logo-only.svg' } contract_metadata = { "" : "ipfs://QmaiAUj1FFNGYTu8rLBjc3eeN9cSKwaF8EGMBNDmhzPNFd", } c2 = FA2.FA2(config = FA2.environment_config(), metadata = sp.utils.metadata_of_url("https://example.com"), admin = admin.address) c1 = FA2Swap(_admin=admin.address, _fa2=c2.address, _tokenID=0) scenario = sp.test_scenario() scenario.table_of_contents() scenario.h1("Atomic Swap") scenario += c1 scenario.h2("Accounts") scenario.show([admin, alice, bob]) scenario.h2("FA2") scenario.h3("Entry points") scenario += c2 scenario.h3("Admin mints a few coins") tok0_md = FA2.FA2.make_metadata( name = "The Token Zero", decimals = 2, symbol= "TK0" ) scenario += c2.mint(address = alice.address, amount = 18, metadata = tok0_md, token_id = 0).run(sender = admin) scenario.h2("Alice approves Contract") scenario += c2.update_operators([ sp.variant("add_operator", c2.operator_param.make( owner = alice.address, operator = c1.address, token_id = 0)) ]).run(sender = alice) scenario.h2("Swap[Wait] Testing") # no operations work without contract being active scenario += c1.initiateWait(_hashedSecret=hashSecret, initiator_eth_addr=init_eth, _refundTimestamp=sp.timestamp( 159682500), _amount=5).run(sender=alice, now=sp.timestamp(159682400), valid=False) # activate only by admin scenario += c1.toggleContractState(True).run(sender=alice, valid=False) scenario += c1.toggleContractState(True).run(sender=admin) # update reward only by admin scenario += c1.updateReward(50).run(sender=alice, valid=False) scenario += c1.updateReward(50).run(sender=admin) # initiate new swap scenario += c1.initiateWait(_hashedSecret=hashSecret, initiator_eth_addr=init_eth, _refundTimestamp=sp.timestamp( 159682500), _amount=5).run(sender=alice, now=sp.timestamp(159682400)) # balance check scenario.verify(c2.data.ledger[c2.ledger_key.make(c1.address, 0)].balance == sp.nat(5)) scenario.verify(c2.data.ledger[c2.ledger_key.make(alice.address, 0)].balance == sp.nat(13)) # cannot redeem before it is activated & initiated scenario += c1.redeem(_hashedSecret=hashSecret, _secret=sp.bytes( "0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a")).run(sender=bob, now=sp.timestamp(159682450), valid=False) # successful add participant only by initiator scenario += c1.addCounterParty(_hashedSecret=hashSecret, _participant=bob.address).run(sender=bob, valid=False) # successful add participant only by initiator scenario += c1.addCounterParty(_hashedSecret=hashSecret, _participant=bob.address).run(sender=alice) # cannot be redeemed with wrong secret scenario += c1.redeem(_hashedSecret=hashSecret, _secret=sp.bytes( "0x12345678aa")).run(sender=bob, now=sp.timestamp(159682450), valid=False) # cannot be redeemed after refundtime has come scenario += c1.redeem(_hashedSecret=hashSecret, _secret=sp.bytes( "0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a")).run(sender=bob, now=sp.timestamp(159682550), valid=False) # new swap with the same hash cannot be added unless the previous one is redeemed/refunded scenario += c1.initiateWait(_hashedSecret=hashSecret, initiator_eth_addr=init_eth, _refundTimestamp=sp.timestamp( 159682500), _amount=5).run(sender=alice, amount=sp.tez(2), now=sp.timestamp(159682400), valid=False) # successful redeem can be initiated by anyone but funds transfered to participant scenario += c1.redeem(_hashedSecret=hashSecret, _secret=sp.bytes("0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a")).run(sender=bob, now=sp.timestamp(159682450)) # balance check scenario.verify(c2.data.ledger[c2.ledger_key.make(c1.address, 0)].balance == sp.nat(0)) scenario.verify(c2.data.ledger[c2.ledger_key.make(bob.address, 0)].balance == sp.nat(5)) # successful swap creation with same hash after redeem scenario += c1.initiateWait(_hashedSecret=hashSecret, initiator_eth_addr=init_eth, _refundTimestamp=sp.timestamp( 159682500), _amount=5).run(sender=alice, now=sp.timestamp(159682400)) # balance check scenario.verify(c2.data.ledger[c2.ledger_key.make(c1.address, 0)].balance == sp.nat(5)) scenario.verify(c2.data.ledger[c2.ledger_key.make(alice.address, 0)].balance== sp.nat(8)) # cannot be refunded before the refundtime scenario += c1.refund(hashSecret).run(sender=bob, now=sp.timestamp(159682450), valid=False) scenario += c1.refund(hashSecret).run(sender=alice, now=sp.timestamp(159682450), valid=False) # can be refunded in any initated or waiting state if refund time has come, can be done by anyone but funds transfered only to initiator scenario += c1.refund(hashSecret).run(sender=bob, now=sp.timestamp(159682550)) # cannot be refunded again once it has been refunded scenario += c1.refund(hashSecret).run(sender=alice, now=sp.timestamp(159682550), valid=False) # balance check scenario.verify(c2.data.ledger[c2.ledger_key.make(c1.address, 0)].balance == sp.nat(0)) scenario.verify(c2.data.ledger[c2.ledger_key.make(alice.address, 0)].balance == sp.nat(13))
def __init__(self, admin): self.init(USDPrice = sp.nat(0), keysset = sp.set([admin]) , owner = admin,securities = admin)
def test(): alice = sp.test_account("Alice") bob = sp.test_account("Bob") admin = sp.test_account("Admin") swapHash = sp.bytes("0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a") swapContract = Swap(_admin=admin.address, _swapFee=15, _commission=1000000) token_metadata = { "decimals" : "18", # Mandatory by the spec "name" : "My Great Token", # Recommended "symbol" : "MGT", # Recommended # Extra fields "icon" : 'https://smartpy.io/static/img/logo-only.svg' } contract_metadata = { "" : "ipfs://QmaiAUj1FFNGYTu8rLBjc3eeN9cSKwaF8EGMBNDmhzPNFd", } tokenContract = FA12.FA12(admin.address, config = FA12.FA12_config(support_upgradable_metadata = True), token_metadata = token_metadata, contract_metadata = contract_metadata) scenario = sp.test_scenario() scenario.table_of_contents() scenario.h2("Accounts") scenario.show([admin, alice, bob]) scenario.h2("Swap") scenario += swapContract scenario.h2("FA1.2") scenario += tokenContract scenario.h3("Admin mints token balances to participants") scenario += tokenContract.mint(address=alice.address, value=2000000).run(sender=admin) scenario += tokenContract.mint(address=bob.address, value=3000000).run(sender=admin) scenario.h3("Alice & Bob approve token balances for the Swap contract") scenario += tokenContract.approve(spender=swapContract.address, value=1900000).run(sender=alice) scenario += tokenContract.approve(spender=swapContract.address, value=3000000).run(sender=bob) scenario.h2("Swap Scenarios") scenario.h3("Alice fails to add a swap pair") scenario += swapContract.addSwapPair({"xtz/usdtz":{"xtz": sp.record(counterAsset="usdtz", decimals=6, contract=swapContract.address), "usdtz": sp.record(counterAsset="xtz", decimals=6, contract=tokenContract.address)}}).run(sender=alice, valid=False) scenario.h3("Admin adds a swap pair") scenario += swapContract.addSwapPair({"xtz/usdtz":{"xtz":sp.record(counterAsset="usdtz",decimals=6,contract=swapContract.address), "usdtz":sp.record(counterAsset="xtz",decimals=6,contract=tokenContract.address)}}).run(sender=admin) scenario.h3("Bob fails to offer a swap, swap contract is inactive") # no operations work without contract being active scenario += swapContract.offer(_swapHash=swapHash, _value=2000000, _expected=1900000, _refundTimestamp=sp.timestamp(159682500), _pair="xtz/usdtz", _asset="xtz").run(sender=bob, amount=sp.tez(3), now=sp.timestamp(159682400), valid=False) # activate only by admin scenario.h3("Alice fails activate swap contract") scenario += swapContract.toggleContractState(True).run(sender=alice, valid=False) scenario.h3("Admin activates swap contract") scenario += swapContract.toggleContractState(True).run(sender=admin) # swap must include service fee scenario.h3("Bob fails to offer a swap without service fee included in amount") scenario += swapContract.offer(_swapHash=swapHash, _value=2000000, _expected=1900000, _refundTimestamp=sp.timestamp(159682500), _pair="xtz/usdtz", _asset="xtz").run(sender=bob, amount=sp.tez(2), now=sp.timestamp(159682400), valid=False) # initiate new swap scenario.h3("Bob offers a swap") scenario += swapContract.offer(_swapHash=swapHash, _value=2000000, _expected=1900000, _refundTimestamp=sp.timestamp(159682500), _pair="xtz/usdtz", _asset="xtz").run(sender=bob, amount=sp.tez(3), now=sp.timestamp(159682400)) # cannot initiate new swap with same hash scenario.h3("Alice fails to offer a swap with duplicate hash") scenario += swapContract.offer(_swapHash=swapHash, _value=2000000, _expected=1900000, _refundTimestamp=sp.timestamp(159682500), _pair="xtz/usdtz", _asset="xtz").run(sender=alice, amount=sp.tez(3), now=sp.timestamp(159682400), valid=False) # balance check scenario.verify(swapContract.balance == sp.tez(3)) scenario.h3("Alice fails to take swap below expected return") # cannot redeem without value matching the required expected value scenario += swapContract.take(_swapHash=swapHash, _value=1800000, _pair="xtz/usdtz", _asset="xtz").run(sender=alice, now=sp.timestamp(159682450), valid=False) scenario.h3("Alice takes swap at expected value") scenario += swapContract.take(_swapHash=swapHash, _value=1900000, _pair="xtz/usdtz", _asset="usdtz").run(sender=alice, now=sp.timestamp(159682450)) scenario.verify(swapContract.balance == sp.tez(1)) scenario.verify(tokenContract.data.balances[bob.address].balance == sp.nat(4900000)) scenario.h3("Alice fails to update swap fees") # update fees only by admin scenario += swapContract.updateSwapFees(_swapFee=20, _commission=1500000).run(sender=alice, valid=False) scenario.h3("Admin updates swap fees") scenario += swapContract.updateSwapFees(_swapFee=20, _commission=1500000).run(sender=admin) scenario.h3("Bob fails to offer a swap with outdated fees") # need to use updated service fees scenario += swapContract.offer(_swapHash=swapHash, _value=2000000, _expected=1900000, _refundTimestamp=sp.timestamp(159682500), _pair="xtz/usdtz", _asset="usdtz").run(sender=bob, amount=sp.tez(1), now=sp.timestamp(159682400), valid=False) scenario.h3("Bob offers a new swap with updated commission, reusing a hash") scenario += swapContract.offer(_swapHash=swapHash, _value=2000000, _expected=1900000, _refundTimestamp=sp.timestamp(159682500), _pair="xtz/usdtz", _asset="usdtz").run(sender=bob, amount=sp.utils.nat_to_mutez(1500000), now=sp.timestamp(159682400)) # balance check scenario.verify(swapContract.balance == sp.utils.nat_to_mutez(2500000)) # # cannot be refunded before the refund time scenario += swapContract.refund(swapHash).run(sender=bob, now=sp.timestamp(159682450), valid=False) scenario.h3("Alice refunds Bob's expired swap") # can be refunded by anyone but funds transferred only to initiator after expiry scenario += swapContract.refund(swapHash).run(sender=alice, now=sp.timestamp(159682550)) scenario.h3("Alice fails to refund a removed swap") # cannot be refunded again once it has been refunded scenario += swapContract.refund(swapHash).run(sender=alice, now=sp.timestamp(159682550), valid=False) # balance check [refunded swap service fees are also returned] scenario.verify(swapContract.balance == sp.tez(1)) scenario.h2("Other admin functions") scenario.h3("Alice fails to remove a pair") # only admin can remove swap pair scenario += swapContract.removeSwapPair(["xtz/usdtz"]).run(sender=alice, valid=False) scenario.h3("Admin removes a pair") scenario += swapContract.removeSwapPair(["xtz/usdtz"]).run(sender=admin) # only swap pairs available can be used scenario += swapContract.offer(_swapHash=swapHash, _value=2000000, _expected=1900000, _refundTimestamp=sp.timestamp(159682500), _pair="xtz/usdtz", _asset="xtz").run(sender=bob, amount=sp.utils.nat_to_mutez(3500000), now=sp.timestamp(159682400), valid=False) scenario.h3("Alice fails to set a delegate") voting_powers = { sp.key_hash("tz1YB12JHVHw9GbN66wyfakGYgdTBvokmXQk"): 0, } # only admin can set baker scenario += swapContract.setBaker(sp.some(sp.key_hash("tz1YB12JHVHw9GbN66wyfakGYgdTBvokmXQk"))).run(sender=alice,voting_powers = voting_powers, valid=False) scenario.h3("Admin sets a delegate") scenario += swapContract.setBaker(sp.some(sp.key_hash("tz1YB12JHVHw9GbN66wyfakGYgdTBvokmXQk"))).run(sender=admin,voting_powers = voting_powers) scenario.verify(swapContract.baker==sp.some(sp.key_hash("tz1YB12JHVHw9GbN66wyfakGYgdTBvokmXQk"))) scenario.h3("Alice fails to withdraw commission fees") # only admin can transfer service fees scenario += swapContract.transferFees(bob.address).run(sender=alice, valid=False) scenario.h3("Update Baker") scenario += swapContract.transferFees(bob.address).run(sender=admin) scenario.verify(swapContract.balance == sp.tez(0)) scenario.h3("Transfer rights from Admin to Bob") scenario += swapContract.updateAdmin(bob.address).run(sender=admin)
sp.verify(params.amount >= 1000000000) sp.verify(params.amount % 1000000000 == 0 ) sp.verify(sp.len(self.data.poolSet.elements()) <= self.data.PoolSize) sp.if self.data.poolSet.contains(sp.sender): self.data.LiquidityProvider[sp.sender].amount += params.amount sp.else: sp.if self.data.LiquidityProvider.contains(sp.sender): self.data.LiquidityProvider[sp.sender].amount += params.amount sp.else: self.data.LiquidityProvider[sp.sender] = sp.record(amount=0,premium=sp.nat(0),locked = sp.nat(0)) self.data.LiquidityProvider[sp.sender].amount += params.amount self.data.poolSet.add(sp.sender) self.data.totalSupply += params.amount # Transfer function c = sp.contract(sp.TRecord(from_ = sp.TAddress, to_ = sp.TAddress , value = sp.TNat), self.data.token, entry_point = "transfer").open_some() mydata = sp.record(from_ = sp.sender,to_ = sp.self_address, value = params.amount) sp.transfer(mydata, sp.mutez(0), c)
self.data.shares[sp.sender] = abs(share - sharesBurned) tezPerShare = sp.split_tokens(self.data.tezPool, sp.nat(1), self.data.totalShares) tokensPerShare = sp.nat(self.data.tokenPool / self.data.totalShares) tezDivested = sp.split_tokens(tezPerShare, sharesBurned, sp.nat(1)) tokensDivested = tokensPerShare * sharesBurned sp.verify(tezDivested >= minTez, message="Wrong minTez") sp.verify(tokensDivested >= minTokens, message="Wrong minTokens") self.data.totalShares -= sharesBurned self.data.tezPool -= tezDivested self.data.tokenPool -= tokensDivested sp.if self.data.totalShares == 0: self.data.invariant = sp.mutez(0) sp.else: self.data.invariant = sp.split_tokens(self.data.tezPool, self.data.tokenPool, sp.nat(1)) sp.if self.data.candidates.contains(sp.sender): prevVotes = self.data.votes.get(self.data.candidates[sp.sender], 0) self.data.votes[self.data.candidates[sp.sender]] = abs( prevVotes - sharesBurned) token_contract = sp.contract( sp.TRecord(account_from=sp.TAddress, destination=sp.TAddress, value=sp.TNat), address=self.data.tokenAddress, entry_point="Transfer" ).open_some() sp.transfer(sp.record(account_from=self.data.address,
return allowed @sp.entry_point def Transfer(self, params): account_from = params.account_from destination = params.destination value = params.value sp.if account_from != destination: sp.verify(self.IsAllowed(account_from=account_from, value=value), message="Sender not allowed to spend token from source") src = self.data.ledger[account_from] sp.verify(value <= src.balance, message="Source balance is too low") src.balance = abs(src.balance - value) self.data.ledger[account_from] = src dst = sp.record(balance=sp.nat(0), allowances=sp.map( tkey=sp.TAddress, tvalue=sp.TNat)) self.data.ledger[destination] = self.data.ledger.get(destination, dst) self.data.ledger[destination].balance += value sp.if src.allowances.contains(sp.sender): allow_value = sp.local( "allow_value", src.allowances[sp.sender]).value - value src.allowances[sp.sender] = sp.as_nat(allow_value) self.data.ledger[account_from] = src @sp.entry_point def Mint(self, params): value = params.value sp.verify(sp.sender == self.data.owner, message="You must be the owner of the contract to mint tokens") def_val = sp.record(balance=sp.nat(0), allowances=sp.map(
def empty(self): if self.config.assume_consecutive_token_ids: # The "set" is its cardinal. return sp.nat(0) else: return sp.set(t = token_id_type)
import smartpy as sp from time import sleep LEADERSHIP_PAYMENT_AMOUNT = sp.mutez(200000) # two tenths of a tez COUNTDOWN_DROP_FACTOR = sp.nat(3*60*60*1000) MINIMAL_COUNT_DOWN_MILLISECONDS = sp.nat(5*60*1000) INITIAL_BALANCE = sp.mutez(100000000) class TZButton(sp.Contract): def __init__(self): self.init( leader=sp.address("tz1d393dnaDkbGk8GiKhhy1PX5qgF8XDKpEz"), leadership_start_timestamp=sp.timestamp(999999999999999), countdown_milliseconds = sp.nat(24*60*60*1000) ) @sp.entry_point def default(self, params): sp.verify(sp.amount == LEADERSHIP_PAYMENT_AMOUNT) sp.verify(self.data.leadership_start_timestamp.add_seconds(sp.to_int(self.data.countdown_milliseconds/1000)) > sp.now) self.data.leader = sp.sender self.data.leadership_start_timestamp = sp.now balance_weight_tenthtez = sp.fst(sp.ediv(sp.balance-INITIAL_BALANCE,sp.mutez(1)).open_some())/sp.nat(100000) # mutez becomes tenth of a tez countdown_drop_milliseconds = (COUNTDOWN_DROP_FACTOR+balance_weight_tenthtez)/balance_weight_tenthtez sp.if self.data.countdown_milliseconds - countdown_drop_milliseconds > sp.to_int(MINIMAL_COUNT_DOWN_MILLISECONDS): self.data.countdown_milliseconds = sp.as_nat(self.data.countdown_milliseconds - countdown_drop_milliseconds) sp.else: self.data.countdown_milliseconds = MINIMAL_COUNT_DOWN_MILLISECONDS
sp.TVariant( add_operator = UpdateOperatorsRequest.get_operator_param_type(), remove_operator = UpdateOperatorsRequest.get_operator_param_type()) ) class TokenMetadata(): def get_type(): return sp.TRecord( token_id=sp.TNat, token_info=sp.TMap(k = sp.TString, v= sp.TBytes)).layout(("token_id", "token_info")) INITIAL_BID = sp.mutez(900000) MINIMAL_BID = sp.mutez(100000) INITIAL_AUCTION_DURATION = sp.int(24*5) MINIMAL_AUCTION_DURATION = sp.int(1) MAXIMAL_AUCTION_DURATION = sp.int(24*7) MAXIMAL_TOKEN_ID = sp.nat(1689) THRESHOLD_ADDRESS = sp.address("tz3jfebmewtfXYD1Xef34TwrfMg2rrrw6oum") # this is the biggest tz3 after this only KT... DEFAULT_ADDRESS = sp.address("tz1RKmJwoAiaqFdjQYSbFy1j7u7UhEFsqXq7") AUCTION_EXTENSION_THRESHOLD = sp.int(60*5) # 5 minutes BID_STEP_THRESHOLD = sp.mutez(100000) class AcuteArtFA2(sp.Contract): def __init__(self, initial_auction_house_address, minter): self.init( initial_auction_house_address = initial_auction_house_address, ledger = sp.big_map(tkey=LedgerKey.get_type(), tvalue=sp.TNat), token_metadata = sp.big_map(tkey=sp.TNat, tvalue=TokenMetadata.get_type()), total_supply=sp.big_map(tkey=sp.TNat, tvalue=sp.TNat), allowances = sp.big_map(tkey=AllowanceKey.get_type(), tvalue=sp.TBool), minter = minter, token_royalties = sp.big_map(tkey=sp.TNat, tvalue=sp.TUnit),
def __init__(self): self.init( leader=sp.address("tz1d393dnaDkbGk8GiKhhy1PX5qgF8XDKpEz"), leadership_start_timestamp=sp.timestamp(999999999999999), countdown_milliseconds = sp.nat(24*60*60*1000) )
def test(): c1 = HENDao([sp.address("tz1owner1"), sp.address("tz1owner2")]) scenario = sp.test_scenario() scenario.h1("Test Buy") scenario += c1 user1 = sp.address("tz1owner1") user2 = sp.address("tz1owner2") scenario.h2("Buying disabled when locked") c1.vote_buy(swap_id=sp.nat(123), price=sp.mutez(0), objkt_amount=sp.nat(1)).run(valid=False, sender=user1) scenario.h2("Buying enabled when unlocked") c1.vote_lock(True).run(sender=user1) c1.vote_lock(True).run(sender=user2) c1.vote_buy(swap_id=sp.nat(123), objkt_amount=sp.nat(1), price=sp.mutez(0)).run(sender=user1) # Proposal should pass c1.vote_buy(swap_id=sp.nat(123), objkt_amount=sp.nat(1), price=sp.mutez(0)).run(sender=user2) scenario.verify(c1.data.buy_proposals[123].passed == True) # Double vote fails c1.vote_buy(swap_id=sp.nat(123), objkt_amount=sp.nat(1), price=sp.mutez(0)).run(sender=user2, valid=False) c1.vote_buy(swap_id=sp.nat(123), objkt_amount=sp.nat(1), price=sp.mutez(0)).run(sender=user1, valid=False) # Test undo c1.vote_buy(swap_id=sp.nat(456), objkt_amount=sp.nat(1), price=sp.mutez(5)).run(sender=user1) c1.undo_vote_buy(456).run(sender=user1) scenario.verify(c1.data.buy_proposals[456].votes.contains(user1) == False)
def default(self, params): sp.verify(sp.amount == LEADERSHIP_PAYMENT_AMOUNT) sp.verify(self.data.leadership_start_timestamp.add_seconds(sp.to_int(self.data.countdown_milliseconds/1000)) > sp.now) self.data.leader = sp.sender self.data.leadership_start_timestamp = sp.now balance_weight_tenthtez = sp.fst(sp.ediv(sp.balance-INITIAL_BALANCE,sp.mutez(1)).open_some())/sp.nat(100000) # mutez becomes tenth of a tez countdown_drop_milliseconds = (COUNTDOWN_DROP_FACTOR+balance_weight_tenthtez)/balance_weight_tenthtez sp.if self.data.countdown_milliseconds - countdown_drop_milliseconds > sp.to_int(MINIMAL_COUNT_DOWN_MILLISECONDS): self.data.countdown_milliseconds = sp.as_nat(self.data.countdown_milliseconds - countdown_drop_milliseconds)
self.addAddressIfNecessary(sp.sender) sp.verify(~self.is_paused(), FA12_Error.Paused) alreadyApproved = self.data.balances[sp.sender].approvals.get(params.spender, 0) sp.verify((alreadyApproved == 0) | (params.value == 0), FA12_Error.UnsafeAllowanceChange) self.data.balances[sp.sender].approvals[params.spender] = params.value def addAddressIfNecessary(self, address): sp.if ~ self.data.balances.contains(address): self.data.balances[address] = sp.record(balance = 0, approvals = {}) @sp.utils.view(sp.TNat) def getBalance(self, params): sp.if self.data.balances.contains(params): sp.result(self.data.balances[params].balance) sp.else: sp.result(sp.nat(0)) @sp.utils.view(sp.TNat) def getAllowance(self, params): sp.if self.data.balances.contains(params.owner): sp.result(self.data.balances[params.owner].approvals.get(params.spender, 0)) sp.else: sp.result(sp.nat(0)) @sp.utils.view(sp.TNat) def getTotalSupply(self, params): sp.set_type(params, sp.TUnit) sp.result(self.data.totalSupply) # this is not part of the standard but can be supported through inheritance. def is_paused(self):
class AdministratorState: """Static enum used for the admin rights and propose flow""" IS_ADMIN = sp.nat(1) """This state shows that the admin right is there""" IS_PROPOSED_ADMIN = sp.nat(2) """This state shows that the admin has been proposed but not full admin yet"""
def __init__( self, governorAddress=sp.address("tz1abmz7jiCV2GH2u81LRrGgAFFgvQgiDiaf"), ): self.init(governorAddress=governorAddress, value=sp.nat(0))
def test(): admin = sp.test_account("Administrator") alice = sp.test_account("Alice") bob = sp.test_account("Bob") init_eth = "0x91f79893E7B923410Ef1aEba6a67c6fab0sfsdgffd" hashSecret = sp.sha256( sp.sha256( sp.bytes( "0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a" ))) c2 = FA12.FA12(admin.address) c1 = TokenSwap(_admin=admin.address, _fa12=c2.address) scenario = sp.test_scenario() scenario.table_of_contents() scenario.h1("Atomic Swap") scenario += c1 scenario.h2("Accounts") scenario.show([admin, alice, bob]) scenario.h2("FA1.2") scenario.h3("Entry points") scenario += c2 scenario.h3("Admin mints a few coins") scenario += c2.mint(address=alice.address, value=12).run(sender=admin) scenario += c2.mint(address=alice.address, value=3).run(sender=admin) scenario += c2.mint(address=alice.address, value=3).run(sender=admin) scenario.h2("Alice approves Contract") scenario += c2.approve(spender=c1.address, value=10).run(sender=alice) scenario.h2("Swap[Wait] Testing") # no operations work without contract being active scenario += c1.initiateWait(_hashedSecret=hashSecret, initiator_eth_addr=init_eth, _refundTimestamp=sp.timestamp(159682500), _amount=5).run(sender=alice, now=sp.timestamp(159682400), valid=False) # activate only by admin scenario += c1.toggleContractState(True).run(sender=alice, valid=False) scenario += c1.toggleContractState(True).run(sender=admin) # update reward only by admin scenario += c1.updateReward(50).run(sender=alice, valid=False) scenario += c1.updateReward(50).run(sender=admin) # initiate new swap scenario += c1.initiateWait(_hashedSecret=hashSecret, initiator_eth_addr=init_eth, _refundTimestamp=sp.timestamp(159682500), _amount=5).run(sender=alice, now=sp.timestamp(159682400)) # balance check scenario.verify(c2.data.balances[c1.address].balance == sp.nat(5)) scenario.verify(c2.data.balances[alice.address].balance == sp.nat(13)) # cannot redeem before it is activated & initiated scenario += c1.redeem( _hashedSecret=hashSecret, _secret=sp.bytes( "0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a" )).run(sender=bob, now=sp.timestamp(159682450), valid=False) # successful add participant only by initiator scenario += c1.addCounterParty(_hashedSecret=hashSecret, _participant=bob.address).run(sender=bob, valid=False) # successful add participant only by initiator scenario += c1.addCounterParty(_hashedSecret=hashSecret, _participant=bob.address).run(sender=alice) # cannot be redeemed with wrong secret scenario += c1.redeem(_hashedSecret=hashSecret, _secret=sp.bytes("0x12345678aa")).run( sender=bob, now=sp.timestamp(159682450), valid=False) # cannot be redeemed after refundtime has come scenario += c1.redeem( _hashedSecret=hashSecret, _secret=sp.bytes( "0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a" )).run(sender=bob, now=sp.timestamp(159682550), valid=False) # new swap with the same hash cannot be added unless the previous one is redeemed/refunded scenario += c1.initiateWait(_hashedSecret=hashSecret, initiator_eth_addr=init_eth, _refundTimestamp=sp.timestamp(159682500), _amount=5).run(sender=alice, amount=sp.tez(2), now=sp.timestamp(159682400), valid=False) # successful redeem can be initiated by anyone but funds transfered to participant scenario += c1.redeem( _hashedSecret=hashSecret, _secret=sp.bytes( "0x68656c6c6f666473667364666c64736a666c73646a6664736a6673646a6b666a" )).run(sender=bob, now=sp.timestamp(159682450)) # balance check scenario.verify(c2.data.balances[c1.address].balance == sp.nat(0)) scenario.verify(c2.data.balances[bob.address].balance == sp.nat(5)) # successful swap creation with same hash after redeem scenario += c1.initiateWait(_hashedSecret=hashSecret, initiator_eth_addr=init_eth, _refundTimestamp=sp.timestamp(159682500), _amount=5).run(sender=alice, now=sp.timestamp(159682400)) # balance check scenario.verify(c2.data.balances[c1.address].balance == sp.nat(5)) scenario.verify(c2.data.balances[alice.address].balance == sp.nat(8)) # cannot be refunded before the refundtime scenario += c1.refund(hashSecret).run(sender=bob, now=sp.timestamp(159682450), valid=False) scenario += c1.refund(hashSecret).run(sender=alice, now=sp.timestamp(159682450), valid=False) # can be refunded in any initated or waiting state if refund time has come, can be done by anyone but funds transfered only to initiator scenario += c1.refund(hashSecret).run(sender=bob, now=sp.timestamp(159682550)) # cannot be refunded again once it has been refunded scenario += c1.refund(hashSecret).run(sender=alice, now=sp.timestamp(159682550), valid=False) # balance check scenario.verify(c2.data.balances[c1.address].balance == sp.nat(0)) scenario.verify(c2.data.balances[alice.address].balance == sp.nat(13))