def initiateWait(self, _amount, _hashedSecret, _refundTimestamp, initiator_eth_addr): self.contractIsActive() self.isInitiable(_hashedSecret, _refundTimestamp) contract = sp.contract(self.transfer.get_type(), self.data.fa2, "transfer").open_some() sp.transfer([sp.record(from_=sp.sender, txs=[sp.record(to_=sp.self_address, token_id=self.data.tokenID, amount=_amount)])],sp.mutez(0), contract) self.data.swaps[_hashedSecret] = sp.record(hashedSecret=_hashedSecret, initiator_eth_addr=initiator_eth_addr, initiator=sp.sender, participant=sp.sender, refundTimestamp=_refundTimestamp, value=_amount, state=State.Waiting)
def request_tokens(self, targets): sp.set_type(targets, sp.TSet(sp.TAddress)) token = sp.contract(self.token_contract.batch_transfer.get_type(), self.data.token, entry_point = "transfer").open_some(message = "Incompatible token interface") targets = targets.elements().map(lambda target: sp.record(to_ = target, token_id = 0, amount = self.data.max_amount)) sp.transfer([sp.record(from_ = sp.to_address(sp.self), txs = targets)], sp.tez(0), token)
def completeBet(self,params): uuid = self.data.uuid self.data.uuid = self.data.uuid+1 self.data.tempCompleteBetData[uuid] = sp.record(betId = params.betId,betType=params.betType) entryAddress = sp.to_address(sp.self_entry_point(entry_point='completeBetFromOro')) contract = sp.contract(sp.TRecord(uuid=sp.TNat,entryAddress=sp.TAddress),self.data.oracleAddress,entry_point="getDataFromOro").open_some() sp.transfer(sp.record(uuid=uuid,entryAddress=entryAddress),sp.mutez(5000),contract)
def bobSignsState(): scenario.p("Bob signs the current state.") result = sp.make_signature(bob.secret_key, sp.pack( sp.record(id=c1.data.id, name="state", seq=cBob.data.seq, state=cBob.data.baseState))) result = scenario.compute(result) scenario.show(sp.record(seq=cBob.data.seq, sig=result)) return result
def createSealedBidAuctionInstance(self, asset_id, asset_name): sp.verify(sp.sender == self.data.master_auction_contract) contract_address = sp.some(sp.create_contract( storage = sp.record(owner = sp.source, master_auction_contract = sp.to_address(sp.self), asset_id = asset_id, # deposit will get seized if participant tries to cheat deposit = 0, sealed_bids = sp.map(tkey = sp.TAddress, tvalue = sp.TBytes), # TODO: maintain revealed_participants list and only refund those # possibly split the money b/w highest bidder and owner # enforcing all participants to reveal their bids # Then there'll be no need to maintain revealed_count & first_revealed revealed_count = 0, highest_bid = sp.mutez(0), highest_bidder = sp.sender, started = sp.bool(False), first_revealed = sp.bool(False), ended = sp.bool(False), start_time = sp.now, round_time = 0), contract = self.sealed_bid)) # registerInstance c = sp.contract(sp.TRecord(asset_id = sp.TNat, contract_address = sp.TAddress), self.data.master_auction_contract, entry_point = "registerInstance").open_some() sp.transfer(sp.record(asset_id = asset_id, contract_address = contract_address.open_some()), sp.mutez(0), c)
def mutualClose(self, params): sp.verify(self.data.status == OPEN) # Check customer signature sp.verify(sp.check_signature(self.data.custPk, params.custSig, sp.pack(sp.record( chanID = self.data.chanID, custAddr = self.data.custAddr, merchAddr = self.data.merchAddr, custBal = params.custBal, merchBal = params.merchBal) ) )) # Check merchant signature sp.verify(sp.check_signature(self.data.merchPk, params.merchSig, sp.pack(sp.record( chanID = self.data.chanID, custAddr = self.data.custAddr, merchAddr = self.data.merchAddr, custBal = params.custBal, merchBal = params.merchBal) ) )) self.data.custBal = params.custBal self.data.merchBal = params.merchBal sp.send(self.data.custAddr, self.data.custBal) sp.send(self.data.merchAddr, self.data.merchBal) self.data.custBal = sp.tez(0) self.data.merchBal = sp.tez(0) self.data.status = CLOSED
def createDutchAuctionInstance(self, asset_id): sp.verify(sp.sender == self.data.master_auction_contract) contract_address = sp.some( sp.create_contract(storage=sp.record( owner=sp.source, master_auction_contract=self.data.master_auction_contract, asset_id=asset_id, current_price=0, reserve_price=0, started=sp.bool(False), ended=sp.bool(False), start_time=sp.now, round_time=0), contract=self.dutch)) # registerInstance c = sp.contract(sp.TRecord(asset_id=sp.TNat, contract_address=sp.TAddress), self.data.master_auction_contract, entry_point="registerInstance").open_some() sp.transfer( sp.record(asset_id=asset_id, contract_address=contract_address.open_some()), sp.mutez(0), c)
def claimFor(self, beneficiery): sp.verify(self.data.schedules.contains(beneficiery)) sp.for schedule_name in self.data.schedules[beneficiery].keys(): schedule = self.data.schedules[beneficiery][schedule_name] vested_amount = self._vested( sp.record( beneficiery= beneficiery, schedule_name= schedule_name ) ) claim_amount = sp.local('claim_amount', sp.as_nat(0)) claim_amount.value = sp.as_nat(vested_amount - schedule.claimed_amount) schedule.claimed_amount += claim_amount.value self._transfer( sp.record( from_ = sp.self_address, to_ = beneficiery, amount = claim_amount.value, token_id = schedule.token_id, token_address = schedule.token_address ) )
def getDataFromOro(self,params): sp.set_type(params.entryAddress,sp.TAddress) errcd = sp.record(uuid=params.uuid,cycleNumber=0) contract = sp.contract(sp.TRecord(uuid = sp.TNat, cycleNumber = sp.TNat),params.entryAddress).open_some() sp.if sp.amount == sp.mutez(5000): sp.transfer(sp.record(uuid=params.uuid,cycleNumber=self.data.cycleNumber),sp.mutez(0),contract)
def request_helper(self, amount, job_id, parameters, oracle, waiting_request_id, target, timeout_minutes=5): sp.verify(~waiting_request_id.is_some()) target = sp.set_type_expr( target, sp.TContract( sp.TRecord(client_request_id=sp.TNat, result=value_type))) waiting_request_id.set(sp.some(self.data.next_request_id)) token = sp.contract(sp.TRecord(oracle=sp.TAddress, params=request_type), self.data.token, entry_point="proxy").open_some() params = sp.record(amount=amount, target=sp.to_address(target), job_id=job_id, parameters=parameters, timeout=sp.now.add_minutes(timeout_minutes), client_request_id=self.data.next_request_id) sp.transfer(sp.record(oracle=oracle, params=params), sp.mutez(0), token) self.data.next_request_id += 1
def mint_OBJKT(self, params): sp.verify((params.amount > 0) & ((params.royalties >= 0) & (params.royalties <= 250)) & (params.amount <= 10000)) c = sp.contract( sp.TRecord( address=sp.TAddress, amount=sp.TNat, token_id=sp.TNat, token_info=sp.TMap(sp.TString, sp.TBytes) ), self.data.objkt, entry_point = "mint").open_some() sp.transfer( sp.record( address=params.address, amount=params.amount, token_id=self.data.objkt_id, token_info={ '' : params.metadata } ), sp.mutez(0), c) self.data.royalties[self.data.objkt_id] = sp.record(issuer=sp.sender, royalties=params.royalties) self.data.objkt_id += 1
def __init__(self): self.init( powerups=[ sp.record(power="time_freeze", duration=3), sp.record(power="one_shot_kill", duration=4) ] )
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(): scenario = sp.test_scenario() scenario.h1("Minimal") c1 = EthClientOnTezos() scenario += c1 scenario += c1.increment(sp.record(block = sp.record(hash = sp.string('sdhkf')) )) scenario += c1 scenario += c1.add_block_header(sp.record(block = sp.record(parent_hash = sp.string('sdfsdf'), header_hash = sp.string('dfsdf'),header_number = 8)))
def placeBet(self,params): sp.verify(self.data.betData.contains(params.betType), message="incorrect bet type") sp.verify_equal(sp.amount,sp.mutez(self.data.betSize[params.betType]),message="incorrect amount sent to the entry point") # multiplied seed by 10000 to retain last 6 digits of timestamp uuid = self.data.uuid self.data.uuid = self.data.uuid+1 self.data.tempData[uuid] = sp.record(seed=params.seed,sender=sp.sender,betType=params.betType) entryAddress = sp.to_address(sp.self_entry_point(entry_point='placeBetFromOro')) contract = sp.contract(sp.TRecord(uuid=sp.TNat,entryAddress=sp.TAddress),self.data.oracleAddress,entry_point="getDataFromOro").open_some() sp.transfer(sp.record(uuid=uuid,entryAddress=entryAddress),sp.mutez(5000),contract)
def initiateWait(self, _amount, _hashedSecret, _refundTimestamp, initiator_eth_addr): self.contractIsActive() self.isInitiable(_hashedSecret, _refundTimestamp) c = sp.contract(sp.TRecord(from_=sp.TAddress, to_=sp.TAddress, value=sp.TNat).layout(("from_ as from", ("to_ as to", "value"))), self.data.fa12, entry_point="transfer").open_some() transferData = sp.record( from_=sp.sender, to_=sp.self_address, value=_amount) sp.transfer(transferData, sp.mutez(0), c) self.data.swaps[_hashedSecret] = sp.record(hashedSecret=_hashedSecret, initiator_eth_addr=initiator_eth_addr, initiator=sp.sender, participant=sp.sender, refundTimestamp=_refundTimestamp, value=_amount, state=State.Waiting)
def test(): scenario = sp.test_scenario() scenario.h1("PS sig verification") pubkey = sp.record(g2=1, X=2, Y0=3, Y1=4, Y2=5, Y3=6, Y4=7) c1 = PsSigContract(pubkey) wallet = sp.record(m0=8, m1=9, m2=10, m3=11, m4=12) signature = sp.record(s1=13, s2=14) scenario += c1 scenario += c1.ps_sig_verify(wallet=wallet, signature=signature).run() scenario.table_of_contents()
def Contract_Initialisation(self, price, start_date, dep_date, nuki, deposit, fair, owner, visitor, contract): self.data.price = price sp.verify(start_date != dep_date) self.data.start_date = start_date self.data.dep_date = dep_date self.data.nuki = nuki self.data.deposit = deposit self.data.fair = fair self.data.balances[owner] = sp.record(balance = sp.tez(100)) self.data.balances[contract] = sp.record(balance = sp.tez(0)) self.data.balances[visitor] = sp.record(balance = sp.tez(100))
def f_process_request(req): user = self.ledger_key.make(req.owner, req.token_id) sp.verify(self.data.token_metadata.contains(req.token_id), message = self.error_message.token_undefined()) sp.if self.data.ledger.contains(user): balance = self.data.ledger[user].balance sp.result( sp.record( request = sp.record( owner = sp.set_type_expr(req.owner, sp.TAddress), token_id = sp.set_type_expr(req.token_id, sp.TNat)), balance = balance))
def contribute(self, params): sp.verify(sp.now <= self.data.end_date) tezValue=sp.tez(sp.as_nat(params.amount)) sp.verify(sp.amount == tezValue) c = sp.contract(sp.TRecord(address = sp.TAddress, amount = sp.TInt), self.data.tokenContract, entry_point = "mint").open_some() sp.if self.data.xtzContributionTotal < 50000 : mydata = sp.record(address = sp.sender,amount=params.amount*1200) sp.transfer(mydata, sp.amount, c) mydata = sp.record(address = self.data.administrator,amount=params.amount*120) sp.transfer(mydata, sp.mutez(0), c)
def addDAO(self,stre,mincontribution,mtoken,vstart,vend,disend,cont): sp.set_type(mincontribution, sp.TMutez) mincontribution=mincontribution sp.verify(sp.now<disend) sp.if self.data.addmemberdata.contains(sp.sender)==False: self.data.DAO_id +=1 keyindex=self.data.DAO_id sp.verify(sp.amount == mincontribution) self.data.addDAOdata[keyindex] = sp.record(admin=sp.sender,strength=stre,min_contribution=mincontribution,serialno=keyindex,winproposalid=-1,winprojectid=-1,maxtoken=mtoken,proposedproposalid=-1,proposedprojectid=-1,disputevotecount=0,maxmember=1,disputestatus=0,rewardstatus=0,votestart=vstart,voteend=vend,disputeend=disend,currentcount=1,contri=cont) self.data.addmemberdata[sp.sender]=sp.record(DAO=keyindex,contribution=sp.amount,tokenbalance=mtoken)
def test(): scenario = sp.test_scenario() oracle = PlayerFantasyPointsOracle( sp.address('tz1dJVWP5nAd2dfNQhpDQdGefQoED7aRy8qn')) scenario += oracle scenario += oracle.feedData(array=[sp.record(player_id=0, points=369, rank=1), sp.record(player_id=1, points=284, rank=2), sp.record(player_id=2, points=260, rank=3)]).run(sender=sp.address('tz1beX9ZDev6SVVW9yJwNYA89362ZpWuDwou')) scenario += oracle.getDataFromOrO().run(sender=sp.address("KT1-AAA"), amount=sp.mutez(5000)) scenario += oracle.getDataFromOrO().run(sender=sp.address("KT1-BBB"), amount=sp.mutez(4000))
def create_auction(self, create_auction_request): sp.set_type_expr(create_auction_request, AuctionCreateRequest.get_type()) token_contract = sp.contract(BatchTransfer.get_type(), create_auction_request.token_address, entry_point = "transfer").open_some() sp.verify(create_auction_request.token_amount > 0, message=AuctionErrorMessage.TOKEN_AMOUNT_TOO_LOW) sp.verify(create_auction_request.end_timestamp >= sp.now.add_hours(MINIMAL_AUCTION_DURATION), message=AuctionErrorMessage.END_DATE_TOO_SOON) sp.verify(create_auction_request.end_timestamp <= sp.now.add_hours(MAXIMAL_AUCTION_DURATION), message=AuctionErrorMessage.END_DATE_TOO_LATE) sp.verify(create_auction_request.bid_amount >= MINIMAL_BID, message=AuctionErrorMessage.BID_AMOUNT_TOO_LOW) sp.verify(~self.data.auctions.contains(create_auction_request.auction_id), message=AuctionErrorMessage.ID_ALREADY_IN_USE) sp.transfer([BatchTransfer.item(sp.sender, [sp.record(to_=sp.self_address, token_id=create_auction_request.token_id, amount=create_auction_request.token_amount)])], sp.mutez(0), token_contract) self.data.auctions[create_auction_request.auction_id] = sp.record(token_address=create_auction_request.token_address, token_id=create_auction_request.token_id, token_amount=create_auction_request.token_amount, end_timestamp=create_auction_request.end_timestamp, seller=sp.sender, bid_amount=create_auction_request.bid_amount, bidder=sp.sender)
def proxy(self, oracle, params): self.transfer.f(self, [ sp.record( from_=sp.sender, txs=[sp.record(to_=oracle, token_id=0, amount=params.amount)]) ]) oracle_contract = sp.contract( sp.TRecord(client=sp.TAddress, params=request_type), oracle, entry_point="create_request").open_some() sp.transfer(sp.record(client=sp.sender, params=params), sp.mutez(0), oracle_contract)
def sendQuery(self, params): handler = sp.contract(qType, self.data.oracle, entry_point="makeQuery").open_some() args = sp.record( # id = params.id, jurisdiction=params.jurisdiction, companyNumber=params.companyNumber, callback=sp.record(address=sp.to_address(sp.self), entryPoint="receiveAnswer") #sp.contract(rType, sp.to_address(sp.self), entry_point = "receiveAnswer").open_some() ) sp.transfer(args, sp.tez(0), handler)
def balance_of(self, params): sp.set_type(params, BalanceOf.entry_point_type()) res = sp.local("responses", []) sp.set_type(res.value, BalanceOf.response_type()) sp.for req in params.requests: user = LedgerKey.make(req.owner, req.token_id) balance = self.data.ledger[user] res.value.push( sp.record( request=sp.record( owner=sp.set_type_expr(req.owner, sp.TAddress), token_id=sp.set_type_expr(req.token_id, sp.TNat)), balance=balance))
def cancel_request(self, client_request_id): # We do not want to check active here (it would be bad for the client). # sp.sender needs to be validated; this process is done through the use of the reverse_request_key. reverse_request_key = sp.compute(sp.record(client = sp.sender, client_request_id = client_request_id)) request_id = sp.local('request_id', self.data.reverse_requests[reverse_request_key]).value request = sp.local('request', self.data.requests[request_id]).value sp.verify(request.timeout <= sp.now, message = "TTL not met") token = sp.contract(self.token_contract.batch_transfer.get_type(), self.data.token, entry_point = "transfer").open_some(message = "Incompatible token interface") sp.transfer([sp.record(from_ = sp.to_address(sp.self), txs = [sp.record(to_ = request.client, token_id = 0, amount = request.amount)])], sp.tez(0), token) del self.data.requests[request_id] del self.data.reverse_requests[reverse_request_key]
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 OpenVault(self,params): self.data.contract = sp.create_contract(storage=sp.record(token=sp.nat(0),xtz=sp.nat(0), owner = sp.sender, oracle = self.data.oracle , Closed = True,stablecoin = self.data.token, Insurance = sp.now, securityDelegator = sp.sender ), contract = self.Vault ) c = sp.contract(sp.TRecord( address = sp.TAddress, owner = sp.TAddress), self.data.token, entry_point = "AddVault").open_some() mydata = sp.record(address = self.data.contract , owner = sp.sender) sp.transfer(mydata, sp.mutez(0), c)
def balance_of(self, params): # paused may mean that balances are meaningless: sp.verify( ~self.data.paused ) res = sp.local("responses", []) sp.set_type(res.value, Balance_of.response_type()) sp.for req in params.requests: user = Ledger_key.make(req.owner, req.token_id) balance = self.data.ledger[user].balance res.value.push( sp.record( request = sp.record( owner = sp.set_type(req.owner, sp.TAddress), token_id = sp.set_type(req.token_id, sp.TNat)), balance = balance))