def test(): scenario = sp.test_scenario() # sp.test_account generates ED25519 key-pairs deterministically: admin = sp.test_account("Admin") alice = sp.test_account("Alice") bob = sp.test_account("Bob") robert = sp.test_account("Robert") scenario.h1("Contract") oracle = USDOracle(admin.address) scenario += oracle options = Securities(sp.address("tz1XfbFQgxj1sSfe2YyJPba5ZQuKMcV4FXAX"),sp.address("KT1HsVdNMvy4uTeorCFJD2kPVGzHXhpzJZjV"),oracle.address) scenario += options scenario += oracle.feedData(price=230).run(sender=admin) scenario += options.ContractWriter(amount=1000000000).run(sender=alice) scenario += options.ContractWriter(amount=2000000000).run(sender=robert) scenario += oracle.changeSecurities(address=options.address).run(sender=admin) scenario += oracle.SecuritiesPurchase(xtz = 1000000, token = 1000000000 , duration = 1 , spender = bob.address, order = 1).run(sender = bob) scenario += oracle.feedData(price=200).run(sender=admin) scenario += oracle.SecuritiesExercise(owner = bob.address).run(sender = bob )
def test(): # DAO Contract testing# scenario = sp.test_scenario() scenario.h1("Accounts") #scenarionew.show([newadmin, newalice, newbob]) admin = sp.test_account("Administrator") alice = sp.test_account("Alice") bob = sp.test_account("Robert") scenario.show([admin, alice, bob]) daoContract = DAOContract(_Admin=admin.address, members=5, amt=10) fa12 = FA12(daoContract.address) scenario.show([daoContract.address]) scenario.show([fa12.address]) scenario +=daoContract #scenario.h1("Initialize") #scenario += daoContract.intialize(fa12.address).run(sender = admin) scenario.h2("AddRequest") scenario += daoContract.addrequest(amt=10).run(sender=alice)
def test(): scenario = sp.test_scenario() admin = sp.address("tz1XP2AUZAaCbi1PCNQ7pEdMS1EEjL4p4YPY") mark = sp.test_account("Mark") elon = sp.test_account("Mars") alice = sp.test_account("alice") # (1) Initialize Cryptobot as `cryptobot` with non_fungible set to True. # (2) Add it to the scenario. cryptobot = Cryptobot(FA2.FA2_config(non_fungible = True), admin) scenario += cryptobot # Mint 1 token to mark with symbol - "CTB", amount - 1, token_id - 0 and extras - {"value": "First bot"} scenario += cryptobot.mint(address = mark.address, amount = 1, symbol = 'CTB', token_id = 5, extras = { "value": "4th bot"}).run(sender = admin) # Mint 1 token to mark with symbol - "CTB", amount - 1, token_id - 1 and extras - {"value": "Second bot"} scenario += cryptobot.mint(address = elon.address, amount = 1, symbol = 'CTB', token_id = 6, extras = { "value": "Second bot" }).run(sender = admin) scenario += cryptobot.offer_bot_for_sale(token_id = 6, min_sale_price = sp.mutez(1000)).run(sender = elon) # scenario += cryptobot.bot_no_longer_for_sale(token_id = 6).run(sender = elon) scenario += cryptobot.enter_bid_for_bot(token_id = 6).run(sender = mark, amount = sp.mutez(10000000)) scenario += cryptobot.enter_bid_for_bot(token_id = 6).run(sender = alice, amount = sp.mutez(12000000)) scenario += cryptobot.widthdraw_bid_for_bot(token_id = 6).run(sender = alice) scenario += cryptobot.accept_bid_for_bot(token_id = 6, nft_amount = 1).run(sender = elon)
def test(): scenario = sp.test_scenario() scenario.h1("ExchangeRateOracle Tests") admin = sp.test_account("Admin") scenario.show(admin) operatorA = sp.test_account("operatorA") scenario.show(operatorA) operatorB = sp.test_account("operatorB") scenario.show(operatorB) caller = sp.test_account("caller") scenario.show(caller) oracle = ExchangeRateOracle(admin.address) scenario.register(oracle) consumer = ExchangeRateConsumer(oracle.address) scenario.register(consumer) scenario += oracle.updateOperatorList(operators = sp.set([operatorA.address, operatorB.address])).run(sender = admin) scenario += oracle.registerFeed(currencyPair = "USDEUR", cost = sp.mutez(1000)).run(sender = admin) scenario += oracle.updateFeed(currencyPair = "USDEUR", value = sp.nat(92), precision = sp.nat(2), timestamp = sp.timestamp(0), source = "Trusted Source").run(sender = operatorA) scenario += consumer.sendQuery(currencyPair = "USDEUR").run(sender = caller, amount = sp.mutez(1000)) scenario.verify(consumer.data.value == 92) scenario.verify(consumer.data.currencyPair == "USDEUR")
def test(): scenario = sp.test_scenario() scenario.h1("FA1.2 template - Fungible assets") # sp.test_account generates ED25519 key-pairs deterministically: admin = sp.address("tz1LAWQmxJcnK43vR9G8jsNTzR6b2unZ58NX") alice = sp.test_account("Alice") bob = sp.test_account("Robert") # Let's display the accounts: scenario.h1("Accounts") scenario.h1("Contract") c1 = ALAToken(admin) scenario.h1("Entry points") scenario += c1 scenario.h2("Admin mints a few coins") scenario += c1.mint(address = alice.address, value = 12).run(sender = alice,amount = sp.tez(12)) scenario += c1.mint(address = bob.address, value = 3).run(sender = admin,amount=sp.tez(3)) # scenario += c1.mint(address = alice.address, value = 3).run(sender = admin) scenario += c1.AddContract(alice.address).run(sender=admin) scenario += c1.UnlockToken(address=bob.address,amount=100).run(sender=alice) scenario += c1.LockToken(address=bob.address,amount=100).run(sender=alice) scenario += c1.withdrawToken(amount=120000).run(sender=alice)
def test(): #Accounts alice = sp.test_account('Alice') bob = sp.test_account('Bob') john = sp.test_account('John') anshu = sp.test_account('Anshu') ronak = sp.test_account('Ronak') scenario = sp.test_scenario() c = SimpleLottery() scenario += c scenario.h1('Lottery Test') scenario += c.buyTicket(1).run(sender = alice, amount = sp.tez(1)) scenario += c.buyTicket(1).run(sender = bob, amount = sp.tez(1)) scenario += c.buyTicket(1).run(sender = john, amount = sp.tez(1)) scenario += c.buyTicket(1).run(sender = ronak, amount = sp.tez(1)) scenario.h3('Buy Multiple (Change)') scenario += c.buyTicket(3).run(sender = anshu, amount = sp.tez(3)) scenario.h3('Final Contract Balance') scenario.show(c.balance)
def test(): scenario = sp.test_scenario() scenario.h1("NFT Contract") admin = sp.test_account("Administrator") alice = sp.test_account("Alice") bob = sp.test_account("Bob") robert = sp.test_account("Robert") dibs = sp.test_account("Dibyo") # Let's display the accounts: scenario.h2("Accounts") scenario.show([admin, alice, bob, robert,dibs]) c1 = TezNFT("state","ST",admin.address) scenario += c1 scenario.h2("Admin minting Tokens") scenario += c1.mintCertificate(token_id = "Kitty1", address = alice.address, name="Alice", score = 20).run(valid = True, sender = admin) scenario += c1.mintCertificate(token_id = "Kitty2", address = bob.address, name="Bob", score = 50).run(sender = admin) scenario += c1.mintCertificate(token_id = "Kitty3", address = bob.address, name="Bob", score = 20).run(sender = admin) scenario += c1.mintCertificate(token_id = "Kitty5", address = alice.address, name="Alice", score = 100).run(sender = admin) scenario += c1.burnCertificate(token_id = "Kitty2").run(valid= True, sender = admin)
def test(): # We define a test scenario, together with some outputs and checks scenario = sp.test_scenario() scenario.h1("Freelantzer Test") # We first define a contract and add it to the scenario c1 = Freelantzer() scenario += c1 lister = sp.test_account("Lister") applier = sp.test_account("Applier") applier2 = sp.test_account("Applier2") applier3 = sp.test_account("Applier3") scenario += c1.list_job(_job_id="1", _company="Company Name", _job_description="link", _contact="+91-9999999999", _max_hires=1).run(source=lister, amount=sp.mutez(1000)) scenario += c1.list_job(_job_id="1", _company="Company Name", _job_description="link", _contact="+91-9999999999", _max_hires=1).run(source=lister, amount=sp.mutez(1000), valid=False) scenario += c1.apply_for_job(_job_id="1", _resume="resume link").run(source=applier) scenario += c1.apply_for_job(_job_id="1", _resume="resume link").run(source=applier) scenario += c1.hire(_job_id="1", _candidate=applier.address, _offer_letter="letter").run(source=lister) scenario.verify(c1.balance == sp.mutez(1000)) scenario += c1.submit(_job_id="1", _candidate=applier.address).run(source=applier, valid=False) scenario += c1.submit(_job_id="1", _candidate=applier.address).run(source=lister) scenario.verify(c1.balance == sp.mutez(0)) scenario += c1.list_job(_job_id="1", _company="Company Name", _job_description="link", _contact="+91-9999999999", _max_hires=2).run(source=lister, amount=sp.mutez(1000)) scenario += c1.apply_for_job(_job_id="1", _resume="resume link").run(source=applier) scenario += c1.apply_for_job(_job_id="1", _resume="resume link").run(source=applier2) scenario += c1.apply_for_job(_job_id="1", _resume="resume link").run(source=applier3) scenario += c1.hire(_job_id="1", _candidate=applier.address, _offer_letter="letter").run(source=lister) scenario += c1.hire(_job_id="1", _candidate=applier2.address, _offer_letter="letter").run(source=lister) scenario += c1.hire(_job_id="1", _candidate=applier3.address, _offer_letter="letter").run(source=lister, valid=False) scenario += c1.submit(_job_id="1", _candidate=applier.address).run(source=lister) scenario += c1.submit(_job_id="1", _candidate=applier3.address).run(source=lister, valid=False) scenario.verify(c1.balance == sp.mutez(500)) scenario += c1.submit(_job_id="1", _candidate=applier2.address).run(source=lister) scenario.verify(c1.balance == sp.mutez(0))
def test(): scenario = sp.test_scenario() admin = sp.test_account("Administrator") alice = sp.test_account("Alice") bob = sp.test_account("Bob") robert = sp.test_account("Robert") dibs = sp.test_account("Dibyo") # Let's display the accounts: scenario.h2("Accounts") scenario.show([admin, alice, bob, robert,dibs]) c1 = DataTokenizer("state","ST",admin.address) scenario += c1 scenario.h2("Admin minting Tokens") scenario += c1.mintDataToken(token_id = "Kitty1", address = alice.address).run(sender = admin) scenario += c1.mintDataToken(token_id = "Kitty2", address = bob.address).run(sender = admin) scenario += c1.mintDataToken(token_id = "Kitty3", address = bob.address).run(sender = admin) scenario += c1.burnDataToken(token_id = "Kitty4").run(valid= False, sender = admin) scenario += c1.transfer(token_id="Kitty2", to= robert.address).run(sender = bob) scenario += c1.approve(token_id = "Kitty2", approve_to=dibs.address).run(sender = robert) scenario += c1.transferFrom(f = robert.address, t= alice.address, token_id = "Kitty2").run(sender = dibs)
def test(): scenario = sp.test_scenario() scenario.h1("FishcakeBox") admin = sp.test_account("Administrator") user1 = sp.test_account("User 1") user2 = sp.test_account("User 2") user3 = sp.test_account("User 3") scenario.show([admin, user1, user2]) token = Fishcake(admin.address) box = FishcakeBox( reward=5, token=token, tokenAddress=sp.address('KT1WVtyDPFzjMkdkihX22LR4y5ye9kGYxjvF')) scenario += token scenario += box scenario += token.mint(address=box.address, amount=100000, symbol='FISH', token_id=0).run(sender=admin) scenario += box scenario += box.redeem().run(sender=user1) scenario += box.redeem().run(sender=user2) scenario += box.redeem().run(sender=user1, valid=False)
def test(): # init test and create html output scenario = sp.test_scenario() scenario.h1("SmartPy Proxy Contract") # init test values owner = sp.test_account("owner") notOwner = sp.test_account("notOwner") oldContract = sp.test_account("old") newContract = sp.test_account("new") # init contract proxy = Proxy(oldContract.address, owner.address) scenario += proxy # sanity check scenario.verify(proxy.data.contract == oldContract.address) # test entrypoints scenario.h2("[ENTRYPOINT] setAddr") scenario.h3("[SUCCESS-setAddr]") scenario += proxy.setAddr(newAddr=newContract.address).run(sender=owner) scenario.verify(proxy.data.contract == newContract.address) scenario.h3("[FAILED-setAddr] Invalid permissions") scenario += proxy.setAddr(newAddr=oldContract.address).run(sender=notOwner, valid=False)
def test(): scenario = sp.test_scenario() admin = sp.test_account("Alice") alice = sp.test_account("Alice") bob = sp.test_account("Robert") alex = sp.test_account("Alex") token = sp.address("KT1KtyJeL78tdHnzwCPE8M14WDb1zqsnLkjQ") oracle = XTZOracle(admin.address) scenario += oracle c1 = PutOptions(admin.address,10,20,token,oracle.address) scenario += c1 scenario += oracle.feedData(price=400).run(sender=admin) scenario += oracle.feedData(price=600).run(sender=admin) scenario += oracle.feedStrike(one=320,two=360,three=400,four=440,five=480).run(sender=admin) scenario += oracle.GetputSeller(Options=1,Ratio=80,address=admin.address,expire=14).run(sender=admin) scenario += c1.RestartCycle().run(sender=admin,now=30) scenario += c1.putSeller(amount=50000).run(now=45,sender=alice,amount=sp.tez(100000)) scenario += c1.putSeller(amount=10000).run(now=45,sender=alice) scenario += c1.putSeller(amount=10000).run(now=45,sender=alex) scenario += c1.putBuyer(Options=1,StrikePrice=100,expire=7).run(sender=bob) #scenario += oracle.getDataMint(address=alice.address,amount=10).run(sender=alice)
def test(): scenario = sp.test_scenario() scenario.h1("FA2 Contract Name: " + config.name) scenario.table_of_contents() # sp.test_account generates ED25519 key-pairs deterministically: admin = sp.test_account("Administrator") alice = sp.test_account("Alice") bob = sp.test_account("Robert") # Let's display the accounts: scenario.h2("Accounts") scenario.show([admin, alice, bob]) c1 = FA2(config, admin.address) scenario += c1 if config.non_fungible: # TODO return scenario.h2("Initial Minting") scenario.p("The administrator mints 100 token-0's to Alice.") scenario += c1.mint(address = alice.address, amount = 100, symbol = 'TK0', token_id = 0).run(sender = admin) scenario.h2("Create certificate") scenario += c1.create_certificate(months = 5).run(sender = bob, amount=sp.mutez(100000000)) scenario.h2("redeem certificate") scenario += c1.redeem_certificate(token_id = 1).run(sender = bob)
def test(): scenario = sp.test_scenario() scenario.h1("FA1.2 template - StableCoin") scenario.table_of_contents() # sp.test_account generates ED25519 key-pairs deterministically: admin = sp.test_account("Administrator") alice = sp.test_account("Alice") bob = sp.test_account("Robert") # Let's display the accounts: scenario.h1("Accounts") scenario.show([admin, alice, bob]) c1 = VaultOpener( sp.address("KT1HsVdNMvy4uTeorCFJD2kPVGzHXhpzJZjV"), sp.address("KT1LiKCNGz2NHvtUH6hhB9usqw8TfuAktusy"), sp.address("tz1XfbFQgxj1sSfe2YyJPba5ZQuKMcV4FXAX") ) scenario += c1 scenario += c1.OpenVault().run(sender=alice,amount=sp.tez(1)) # vault Opener - KT1Q5SPEdRTdki5fVXS7UHikFmWA2ckd3KdA
def test(): scenario = sp.test_scenario() admin = sp.address("tz1LAWQmxJcnK43vR9G8jsNTzR6b2unZ58NX") alice = sp.test_account("Alice") bob = sp.test_account("Robert") alex = sp.test_account("Alex") c1 = ALAToken(admin) c2 = PutOptions(admin,100,120,c1.address) scenario += c1 scenario += c2 scenario += c1.AddContract(c2.address).run(sender=admin) scenario += c1.mint(address = alice.address, value = 2).run(sender = alice,amount = sp.tez(2)) scenario += c2.putSeller(amount=50000).run(now=45,sender=alice,amount=sp.tez(100000)) scenario += c1.mint(address = bob.address, value = 1).run(sender = bob,amount = sp.tez(1)) scenario += c2.putBuyer(StrikePrice=400,Options=1,expire=14).run(now=50,sender=bob) scenario += c2.WithdrawPremium().run(sender=alice) # scenario += c2.ModifyPrice(price=300).run(sender=admin) # scenario += c2.ReleaseContract().run(sender=bob)
def test(): alice = sp.test_account("Alice") bob = sp.test_account("Robert") scenario = sp.test_scenario() scenario.h1("Atomic Swap") # Here, two AtomicSwap contracts are created. One with Alice as the owner # and Bob as the counterparty, and the second with the identities reversed. # They are both secured with the same hash secret, so if the secret gets # revealed, then both swaps can happen. hashSecret = sp.blake2b(sp.bytes("0x12345678aabb")) c1 = AtomicSwap(sp.mutez(12), sp.timestamp(50), hashSecret, alice.address, bob.address) c2 = AtomicSwap(sp.mutez(20), sp.timestamp(50), hashSecret, bob.address, alice.address) scenario.h1("c1") scenario += c1 scenario += c1.knownSecret(secret = sp.bytes("0x12345678aa")).run(sender = bob, valid = False) scenario += c1.knownSecret(secret = sp.bytes("0x12345678aabb")).run(sender = bob) scenario.h1("c2") scenario += c2 scenario.h2("C2.export()") scenario.p(c2.export())
def test1(): scenario = sp.test_scenario() scenario.h1("Candidates") # Candidates addr1 = sp.address("tz1LhS2WFCinpwUTdUb991ocL2D9Uk6FJGJK") addr2 = sp.address("tz1a6SkBrxCywRHHsUKN3uQse7huiBNSGb5p") addr3 = sp.address("tz3WXYtyDUNL91qfiCJtVUX746QpNv5i5ve5") # Manager - can end the voting addr4 = sp.address("tz1SwKQDtW8H7xLAS9ag4nxXbsQP5Pejwr7z") # Voters addr5 = sp.address("tz1SwKQDtW8H7xLAS9ag4nxXbsQP5Pejwr7z") addr6 = sp.address("tz1YH2LE6p7Sj16vF6irfHX92QV45XAZYHnX") contract = Ballot("Design", addr4, [(addr1, "George"), (addr2, "Tim"), (addr3, "Gina")], [addr5, addr6], 2) contract.balance = sp.tez(9) scenario += contract # Votes succeed scenario += contract.vote(votes = {addr1: 2}).run(valid = True,sender = addr5) scenario += contract.vote(votes = {addr2: 1}).run(valid = True, sender = addr6) # Not enough votes - vote fails scenario += contract.vote(votes = {addr1: 1}).run(valid=False,sender = addr5) # Assert addr1 has 2 votes, addr2 has 1 vote scenario.verify(contract.data.ballot[addr1] == sp.record(candidateName = "George", numberOfVotes = 2)) scenario.verify(contract.data.ballot[addr2] == sp.record(candidateName = "Tim", numberOfVotes = 1)) # Ending contract scenario += contract.end().run(valid = True, sender = addr4) # Testing logic for ending contract scenario.h1("End") voterAccount = sp.test_account("Voter") candidateAccount = sp.test_account("Canddidate") managerAccount = sp.test_account("Manager") contract = Ballot("End", managerAccount.address, [(candidateAccount.address, "Candidate")], [voterAccount.address], 10) scenario += contract # Vote for open voting succeeds scenario += contract.vote(votes = {candidateAccount.address: 1}).run(valid = True, sender = voterAccount) # Ending vote with voterAccount fails scenario += contract.end().run(valid = False, sender = voterAccount) # Ending vote with managerAccount succeeds scenario += contract.end().run(valid = True, sender = managerAccount) # Voting after ending fails scenario += contract.vote(votes = {candidateAccount.address: 1}).run(valid = False, sender = voterAccount) # Ending contract again fails scenario += contract.end().run(valid = False, sender = managerAccount)
def test(): hashSecret = sp.blake2b(sp.bytes("0x12345678aabb")) alice = sp.test_account("Alice") bob = sp.test_account("Robert") c1 = AtomicSwap(sp.mutez(12), sp.timestamp(50), hashSecret, alice.address, bob.address) scenario = sp.test_scenario() scenario.h1("Atomic Swap") scenario += c1
def test(): time = sp.timestamp(1571761674) # Create test scenario scenario = sp.test_scenario() scenario.table_of_contents() # sp.test_account generates ED25519 key-pairs deterministically: alice = sp.test_account("Alice") bob = sp.test_account("Robert") # Create HTML output for debugging scenario.h1("Dutch Auction") # Instantiate Auction contract auction = DutchAuction(alice.address) scenario += auction alice_wallet = NFTWallet(alice.address) bob_wallet = NFTWallet(bob.address) scenario += alice_wallet scenario += bob_wallet scenario.h2("Create NFT") token_metadata = sp.map({"name": sp.bytes_of_string("Nft1")}) scenario += alice_wallet.createNft(token_metadata).run(sender=alice) scenario.h2("Configure and start auction") scenario += alice_wallet.configNftAuction(auction_address=auction.address, opening_price=100, reserve_price=10, start_time=time, round_time=1000, ticket_id=0).run(source=alice, sender=alice, now=time) scenario.verify(~alice_wallet.data.tickets.contains(0)) time = time.add_seconds(1) scenario += auction.startAuction().run(sender=alice, now=time) time = time.add_seconds(6001) scenario += auction.dropPrice(90).run(sender=alice, now=time) scenario.h2("Bob buys") time = time.add_seconds(1) scenario += auction.buy(bob_wallet.address).run(sender=bob, source=bob, now=time, amount=sp.mutez(90)) scenario.verify(bob_wallet.data.tickets.contains(0)) scenario.verify(~auction.data.ticket.is_some())
def test(): scenario = sp.test_scenario() scenario.h1("TZButton - A social dApp experiment") scenario.table_of_contents() creator = sp.test_account("creator") alice = sp.test_account("Alice") bob = sp.test_account("Robert") dan = sp.test_account("Dan") scenario.h2("Accounts") scenario.show([creator, alice, bob, dan]) tz_button_contract = TZButton() tz_button_contract.set_initial_balance(INITIAL_BALANCE) scenario += tz_button_contract viewer_contract = ViewConsumer() scenario += viewer_contract scenario.h2("Pay-In") scenario.p("Alice does not pay") scenario += tz_button_contract.default().run(sender=alice, valid=False) scenario.p("Alice pays too little") scenario += tz_button_contract.default().run(sender=alice, amount=sp.mutez(20000), valid=False) scenario.p("Alice pays too much") scenario += tz_button_contract.default().run(sender=alice, amount=sp.mutez(20001), valid=False) scenario.p("Alice pays correct amount") scenario += tz_button_contract.default().run(sender=alice, amount=sp.mutez(200000)) scenario.p("Bob pays correct amount") scenario += tz_button_contract.default().run(sender=bob, amount=sp.mutez(200000), now=sp.timestamp(1)) scenario.p("Alice pays correct amount after bob again") scenario += tz_button_contract.default().run(sender=alice, amount=sp.mutez(200000), now=sp.timestamp(2)) scenario.h2("Withdraw") scenario.p("Leader tries to withdraw before countdown") scenario += tz_button_contract.withdraw().run(sender=alice, valid=False) scenario.p("Non-Leader tries to withdraw after countdown") scenario += tz_button_contract.withdraw().run(sender=bob, valid=False, now=sp.timestamp(60*60*24)) scenario.p("Non-Leader tries to pays correct amount after countdown") scenario += tz_button_contract.default().run(sender=bob, amount=sp.mutez(200000), valid=False, now=sp.timestamp(60*60*24)) scenario.p("Leader tries to pays correct amount after countdown") scenario += tz_button_contract.default().run(sender=alice, amount=sp.mutez(200000), valid=False, now=sp.timestamp(60*60*24)) scenario.p("Leader tries to withdraw after countdown") scenario += tz_button_contract.withdraw().run(sender=alice, now=sp.timestamp(60*60*24))
def test(): scenario = sp.test_scenario() scenario.h1("Chainlink Oracles") scenario.table_of_contents() scenario.h2("Accounts") admin = sp.test_account("Administrator") bob = sp.address("tz1WdHqcAo7gjtFDPMgD6yN8pk1sq67MJRjH") oracle1 = sp.test_account("Oracle1") client1_admin = sp.test_account("Client1 admin") client2_admin = sp.test_account("Client2 admin") scenario.show([admin, oracle1, client1_admin, client2_admin]) scenario.h2("Link Token") link_token = Link_token(FA2.FA2_config(single_asset = True), admin.address) scenario += link_token scenario += link_token.mint(address = admin.address, amount = 200, symbol = 'tzLINK', token_id = 0).run(sender = admin) scenario.h2("Token Faucet") faucet = TokenFaucet(admin.address, link_token, link_token.address, 10) scenario += faucet scenario.h2("Oracle") oracle = Oracle(oracle1.address, link_token) scenario += oracle scenario.h2("Client1") client1 = Client(link_token.address, oracle.address, sp.bytes("0x0001"), client1_admin.address) scenario += client1 scenario.h2("Client2") client2 = Client(link_token.address, oracle.address, sp.bytes("0x0001"), client2_admin.address) scenario += client2 scenario.h2("Tokens") scenario += link_token.transfer([sp.record(from_ = admin.address, txs = [sp.record(to_ = faucet.address, token_id = 0, amount = 100)])]).run(sender = admin) scenario += link_token.transfer([sp.record(from_ = admin.address, txs = [sp.record(to_ = oracle1.address, token_id = 0, amount = 1)])]).run(sender = admin) scenario += faucet.request_tokens(sp.set([client1.address, client2.address])) #scenario += link_token.transfer([sp.record(from_ = client1_admin.address, txs = [sp.record(to_ = client1.address, token_id = 0, amount = 10)])]).run(sender = client1_admin) scenario.h2("Client1 sends a request that gets fulfilled") scenario.h3("A request") scenario += client1.request_fortune(payment = 1, timeout = 10).run(sender = bob)
def test(): scenario = sp.test_scenario() admin = sp.address("tz1hPnEdcKWrdeZEAQiGfmV6knHA5En1fCwQ") alice = sp.test_account("Alice") bob = sp.test_account("Robert") alex = sp.test_account("Alex") oracle = XTZOracle(admin) scenario += oracle token = ALAToken(admin,oracle.address) scenario += token options = PutOptions(admin,10,20,token.address,oracle.address) scenario += options scenario += oracle.feedData(price=400).run(sender=admin) scenario += oracle.feedStrike(one=320,two=360,three=400,four=440,five=480).run(sender=admin) scenario += token.mint(address = alice.address, value = 12).run(sender = alice,amount = sp.tez(12)) scenario += token.mint(address = alex.address, value = 5).run(sender = alex,amount = sp.tez(5)) scenario += token.mint(address = bob.address, value = 5).run(sender = bob,amount = sp.tez(5)) scenario += options.RestartCycle().run(sender=admin,now=30) scenario += token.AddContract(options.address).run(sender=admin) scenario += options.putSeller(amount=60000).run(now=45,sender=alice,amount=sp.tez(1)) scenario += options.putSeller(amount=40000).run(now=45,sender=alex) scenario += options.putBuyer(Options=1,StrikePrice=100,expire=7).run(sender=bob) scenario += options.WithdrawPremium().run(sender=alex,now=100) scenario += options.WithdrawPremium().run(sender=alice,now=150) scenario += oracle.feedData(price=100).run(sender=admin) scenario += options.ReleaseContract().run(sender=bob) scenario += options.WithdrawToken().run(sender=alice,now=1987250) scenario += options.WithdrawToken().run(sender=alex,now=1987350) scenario += options.RestartCycle().run(sender=admin,now=2160030)
def test(): scenario = sp.test_scenario() rightful_owner = sp.test_account("Alice") attacker = sp.test_account("Robert") c1 = TestCheckSignature(rightful_owner.public_key) scenario += c1 # Let's build a successful call: # scenario.h2("Successful Call") first_message_packed = sp.pack( sp.record(o="Hello World", n="should work", c=0)) sig_from_alice = sp.make_signature(secret_key=rightful_owner.secret_key, message=first_message_packed, message_format="Raw") scenario += c1.setCurrentValue( newValue="should work", userSignature=sig_from_alice).run(valid=True) # scenario.h2("Replay Attack") scenario.p( "Trying to reuse the same signature is blocked by the value of the counter." ) scenario += c1.setCurrentValue( newValue="should work", userSignature=sig_from_alice).run(valid=False) # # scenario.h2("Signature From Wrong Secret Key") scenario.p("Signing the right thing from a different secret-key.") # # # Gives: second_message_packed = sp.pack( sp.record(o="should work", n="Hello again World", c=1)) sig_from_bob = sp.make_signature(secret_key=attacker.secret_key, message=second_message_packed, message_format="Raw") scenario += c1.setCurrentValue(newValue="Hello again World", userSignature=sig_from_bob).run(valid=False) # scenario.h2("Second Successful Call") scenario.p( "Showing that the previous call failed <b>because</b> of the secret-key (signing same bytes)." ) sig_from_alice = sp.make_signature(secret_key=rightful_owner.secret_key, message=second_message_packed, message_format="Raw") scenario += c1.setCurrentValue( newValue="Hello again World", userSignature=sig_from_alice).run(valid=True)
def test(): alice = sp.test_account('Alice') bob = sp.test_account('Bob') owner = sp.test_account('Owner') c1 = Verification(owner_address=owner.address, init_counter=0) scenario = sp.test_scenario() scenario += c1 c1.increment(value=5).run(sender=alice.address) c1.increment(value=12).run(sender=alice.address, valid=False) c1.increment(value=7).run(sender=alice.address, valid=False) c1.increment(value=8).run(sender=bob.address) c1.decrement(value=2).run(sender=bob.address, valid=False) c1.decrement(value=3).run(sender=owner.address) c1.reset().run(sender=bob.address, valid=False) c1.reset().run(sender=owner.address)
def __init__(self): self.init( guest = sp.test_account("VOID").address, host = sp.test_account("VOID").address, nuki = sp.test_account("VOID").address, rent = sp.tez(0), g_deposit = sp.tez(0), h_deposit = sp.tez(0), active = False, # G engaged/sent deposit in_house = False, # G in house grace_ended = False, # No more complaints complaint = False, # G complained refund = False, # G accepted refund # contract_id = 0, cp = 0)
def Cancellation_Guest(self): sp.verify(self.data.guest == sp.sender) sp.verify(self.data.active == True) sp.verify(self.data.in_house == False) sp.if (self.data.host == sp.test_account("VOID").address): sp.send(self.data.guest, self.data.g_deposit) sp.send(self.data.guest, self.data.rent)
def Guest_Leaves_Contract(self): sp.verify(sp.sender == self.data.guest) sp.verify(self.data.active == True) sp.verify(self.data.in_house == True) self.data.guest = sp.test_account("VOID").address self.data.in_house = False self.data.active = False
def test(): acc = sp.test_account(2) c1 = Wuwei(acc.address, '0x') scenario = sp.test_scenario() scenario.h1("Wuwei Deployment") scenario += c1 scenario.h1("Round inputs") scenario += c1.prices_input( OBJ={ 'CNY': 545, 'BRL': 3131, 'EUR': 242, 'CAN': 5453, 'INR': 42342, 'JPY': 13123, 'KRW': 4232, 'RUB': 52554, 'CHF': 242, 'HKD': 423433, 'SGD': 423, 'AED': 4333, 'QAR': 34 }) scenario.h1("Initialize Client") c2 = Client() scenario += c2 scenario.h1("Request value from key") scenario += c2.request_key(kt=c1.address, key='BRL')
def testEscrow(): html = sp.test_scenario() html.h1("Escrow Cont") seller = sp.test_account("seller") buyer = sp.test_account("buyer") myContract = Escrow() #set the seller and price html += myContract html += myContract.setSeller(price=1).run(sender=seller) #set the buyer html += myContract.setBuyer().run(sender=buyer, amount=sp.tez(2)) # buyer confirms they received item html += myContract.confirmReceived().run(sender=buyer)
def test(): scenario = sp.test_scenario() scenario.h1('Land Register') manager = sp.test_account('Manager') r1 = sp.test_account('Registrar 1') r2 = sp.test_account('Registrar 2') r3 = sp.test_account('Registrar 3') c = LandRegister(manager=manager.address, registrars=sp.set([r1.address, r2.address, r3.address]) ) scenario += c scenario.h2("Add Registrar") r4 = sp.test_account('Registrar 4') scenario += c.add_registrar(registrar=r4.address).run(sender=manager) scenario.h2("Add Registrar with Wrong Manager") wrong = sp.test_account('Wrong Manager') r5 = sp.test_account('Registrar 5') scenario += c.add_registrar(registrar=r5.address).run(sender=wrong, valid=False) scenario.h2("Remove Registrar") scenario += c.remove_registrar(registrar=r1.address).run(sender=manager) scenario.h2("Remove Registrar with Wrong Manager") scenario += c.remove_registrar(registrar=r2.address).run(sender=wrong, valid=False) scenario.h2("Add Land") land_owner = sp.test_account('Land Owner') land = { 'A': (1,2), 'B': (3,2), 'C': (4,3), 'D': (5,4) } code = "ABCD" scenario += c.add_land(owner=land_owner.address, land=land, code=code).run(sender=r3) scenario.h2("Add Land with Wrong Registrar") scenario += c.add_land(owner=land_owner.address, land=land, code=code).run(sender=wrong, valid=False)