def accept_bid_for_bot(self, params): # Make sure that sp.sender has admin access otherwise don't proceed forward # Make sure that contract isn't paused sp.set_type(params.token_id, sp.TNat) sp.set_type(params.nft_amount, sp.TNat) # Make sure that the NFT token id is already present in the ledger sp.verify(self.token_id_set.contains(self.data.all_tokens, params.token_id), "TOKEN ID NOT FOUND") # NFT transfer amount should be 1 sp.verify(params.nft_amount == 1, "NFT AMOUNT OF 1 REQUIRED") # Make sure that the caller is the owner of NFT token id else throw error user = self.ledger_key.make(sp.sender, params.token_id) sp.verify(self.data.ledger.contains(user) == True, "NOT OWNER OF NFT TOKEN ID") # Make sure their is aleast one bid for NFT token id sp.verify(sp.len(self.data.bid[params.token_id]) > 0, "NO BIDDER YET") highest_bidder = sp.local("highest_bidder", sp.record( has_bid = False, bidder = sp.address("tz1iLVzBpCNTGz6tCBK2KHaQ8o44mmhLTBio"), bid_value = sp.mutez(0) )) # transfer the highest bidder value to the seller account sp.for bidder in self.data.bid[params.token_id]: # store highest bidder sp.if bidder.bid_value > highest_bidder.value.bid_value: highest_bidder.value = bidder
def cvrDrop(self, params): sp.verify(sp.sender == self.data.administrator) self.checkLimit(params.amount * sp.to_int(sp.len(params.addresses))) sp.for address in params.addresses: self.addAddressIfNecessary(address) self.data.balances[address].balance += params.amount self.data.circulatingSupply += params.amount
def closeAuction(self, param): sp.if ( sp.len(self.data.bids) > 0 ) : lenCtr = sp.local("lenctr", sp.len(self.data.ctrs)) self.data.ctrs[lenCtr.value] = 0 i = sp.local('i', 0) jc = sp.local('jc', 0) price_i = sp.local("price_i", 0) oneNat = sp.as_nat(1) sp.while ( (i.value < lenCtr.value) & (i.value < sp.len(self.data.bids)) ): price_i.value = 0 jc.value = i.value + oneNat sp.while ( jc.value < (lenCtr.value + 1) ): price_i.value = price_i.value + (self.data.bids[jc.value] * (self.data.ctrs[sp.as_nat(sp.to_int(jc.value) - 1)] - self.data.ctrs[jc.value])) jc.value += 1 self.data.prices[i.value] = price_i.value i.value += 1 del self.data.ctrs[lenCtr.value]
def completeBetFromOro(self,params): sp.verify(sp.sender==self.data.oracleAddress, message="complete bet can be invoked by oro only") data = self.data.tempCompleteBetData[params.uuid] sp.verify(data.betId + data.betType < params.cycleNumber, message="Bet not yet mature") sp.verify(self.data.betSize.contains(data.betType),message="Invalid bet type") # calculate winner betPool = self.data.betData[data.betType][data.betId] winnerIndex = (betPool.seed + abs(sp.now-sp.timestamp(0))) % sp.len(betPool.senderList) # calculating winner amount self.data.earnedAmount = self.data.betSize[data.betType] * sp.len(betPool.senderList) * self.data.yields[data.betType] / 10000 #disburse Amounts i = sp.local('i',0) amount = self.data.earnedAmount * 10 / 100 self.data.adminBalance += sp.mutez(amount) sp.for x in betPool.senderList: sp.if i.value==winnerIndex: amount = self.data.earnedAmount * 90 / 100 + self.data.betSize[data.betType] sp.send(x,sp.mutez(amount))
def resolveAuction(self, params): sp.verify(self.data.started) sp.verify(self.data.first_revealed) sp.verify(~self.data.ended) sp.verify(self.data.sealed_bids.contains(sp.sender)) sp.verify((self.data.revealed_count == sp.len(self.data.sealed_bids)) | (sp.now > self.data.start_time.add_seconds(2 * self.data.round_time))) sp.for bidder in self.data.sealed_bids.keys(): sp.if (~(bidder == self.data.highest_bidder)): # refund participation fee to bidder sp.send(bidder, sp.mutez(self.data.deposit))
def ContractWriter(self,params): sp.set_type(params, sp.TRecord(amount = sp.TNat)) 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
def putSeller(self,params): sp.verify(sp.now < self.data.validation.cycleEnd) sp.verify(params.amount >= 10000) sp.verify(params.amount %10000 == 0 ) # Token Contract Call sp.verify(sp.len(self.data.poolSet.elements()) <= 100) self.Lock(sp.sender,params.amount) sp.if self.data.poolSet.contains(sp.sender): self.data.contractSellar[sp.sender].amount += params.amount
def selectTeam(self, params): # sp.verify(self.data.match_active.contains(params.match_id), message = "Match either does not exists or is inacitve.") sp.verify(sp.len(params.tokens) == 5, message="Only Five Tokens are Allowed.") sp.verify(~self.data.selected_tokens.contains(sp.sender), message = "You have already staked Cards for the match.") self.data.selected_tokens[sp.sender] = sp.record(tokens=sp.set()) sp.for token_id in params.tokens: token_id = sp.set_type_expr(token_id, sp.TNat) sp.verify(self.data.ledger[sp.sender].tokens.contains( token_id), message="You can only select owned tokens.") sp.verify(~self.data.tokens_on_sale.contains( token_id), message="Cannot Play with a token on Sale. Unlist the token to continue.") self.data.tokens[token_id].inMatch = True self.data.selected_tokens[sp.sender].tokens.add(token_id)
def addStudent(self, params): # Assert the types of the relevant variables: SmartPy is strongly typed sp.set_type(params.month, sp.TNat) sp.set_type(params.day, sp.TNat) sp.set_type(params.year, sp.TNat) sp.set_type(params.student, sp.TString) # Necessary logical verification steps before the contract can proceed sp.verify(params.month <= 12) sp.verify(params.day <= 31) sp.verify(sp.len(params.student) > 0) # non-empty student name date = self.date_to_int(params.month, params.day, params.year) self.checkDate(date) self.data.attendanceMap[date].push(params.student)
def test(): c1 = HENDao([sp.address("tz1owner1"), sp.address("tz1owner2")]) scenario = sp.test_scenario() scenario.h1("Test Propose Swap") scenario += c1 user1 = sp.address("tz1owner1") user2 = sp.address("tz1owner2") scenario.h2("Users can call propose swap") c1.vote_lock(True).run(sender=user1) c1.vote_lock(True).run(sender=user2) c1.propose_swap(objkt_amount=sp.nat(1), objkt_id=sp.nat(123), xtz_per_objkt=sp.mutez(10000), creator=user2).run(sender=user1) c1.propose_swap(objkt_amount=sp.nat(1), objkt_id=sp.nat(456), xtz_per_objkt=sp.mutez(100), creator=user2).run(sender=user2) scenario.verify(c1.data.swap_proposals[0].passed == False) scenario.verify(c1.data.swap_proposals[1].passed == False) # Undo votes c1.vote_swap(0).run(sender=user1) scenario.verify(c1.data.swap_proposals[0].votes.contains(user1)) c1.undo_vote_swap(0).run(sender=user1) scenario.verify(~c1.data.swap_proposals[0].votes.contains(user1)) scenario.h2("All votes for a swap") # Vote to pass the proposals c1.vote_swap(0).run(sender=user1) c1.vote_swap(0).run(sender=user2) c1.vote_swap(1).run(sender=user1) c1.vote_swap(1).run(sender=user2) # Test double vote fails c1.vote_swap(0).run(sender=user2, valid=False) # Verify that num votes is valid scenario.verify(sp.len(c1.data.swap_proposals[0].votes) == 2) # Verify that proposal is passed scenario.verify(c1.data.swap_proposals[0].passed == True) scenario.verify(c1.data.swap_proposals[1].passed == True) # Can't undo after passed c1.undo_vote_swap(0).run(sender=user1, valid=False)
def __init__(self, initOwners): # Owners are locked at initialization in this iteration # Future iterations could have dynamic owners self.init( owners=sp.set(initOwners), numOwners=sp.len(initOwners), locked=False, closed=False, lock_votes=sp.set([], sp.TAddress), close_votes=sp.set([], sp.TAddress), total_contributed=sp.mutez(0), total_liquidated=sp.mutez(0), liquidated_ledger=sp.big_map({}, sp.TAddress, sp.TMutez), equity=sp.big_map({}, sp.TAddress, sp.TMutez), buy_proposals=sp.big_map({}, sp.TNat, sp.TRecord(votes=sp.TSet(sp.TAddress), passed=sp.TBool)), swap_proposals=sp.big_map({}), cancel_swap_proposals=sp.big_map({}, sp.TNat, sp.TRecord(votes=sp.TSet(sp.TAddress), passed=sp.TBool)), swap_proposal_id=0, # Used for collect/swap/cancel_swap hen_address = sp.address("KT1HbQepzV1nVGg8QVznG7z4RcHseD5kwqBn"), # Used for update_operators hen_nft_address = sp.address("KT1RJ6PbjHpwc3M5rw5s2Nbmefwbuwbdxton") )
def bid(self, params): l = sp.local('l', sp.len(self.data.bids)) self.data.bids[l.value] = (params) self.data.agents[l.value] = sp.sender
def check_metadata_list(l): res = sp.local("toks", sp.string("")) sp.verify(sp.len(l) == 1) sp.for md in l: sp.verify((md.symbol == "FSCK") & (md.name == "Fishcake"))
self.data.locked & ~self.data.closed ) sp.if self.data.buy_proposals.contains(swap_id): # If already passed, then fail sp.verify(~self.data.buy_proposals[swap_id].passed) self.data.buy_proposals[swap_id].votes.add(sp.sender) sp.else: votes = sp.set() votes.add(sp.sender) self.data.buy_proposals[swap_id] = sp.record(votes=votes, passed=False) # Everyone voted yes, execute the buy sp.if sp.len(self.data.buy_proposals[swap_id].votes) == sp.len(self.data.owners): self.hen_collect(swap_id, price) self.data.buy_proposals[swap_id].passed = True # Undo a vote for a swap @sp.entry_point def undo_vote_buy(self, swap_id): sp.set_type(swap_id, sp.TNat) sp.verify( self.data.owners.contains(sp.sender) & self.data.locked & ~self.data.closed & ~self.data.buy_proposals[swap_id].passed )
def sorting(self): sp.verify(sp.sender == self.data.owner) l = sp.local('l', sp.len(self.data.bids)) j = sp.local('j', l.value - sp.nat(1)) sp.for x in self.data.bids.items(): self.insertSort( x.key )
def cardinal(self, metaset): if self.config.assume_consecutive_token_ids: return metaset else: return sp.len(metaset)
sp.if ~self.data.owners.contains(sp.sender): sp.failwith("not an owner") sp.if ~self.data.locked: sp.failwith("can't buy when unlocked") sp.if self.data.buyMap.contains(params.swap_id): self.data.buyMap[params.swap_id][sp.sender] = True sp.else: props = {} sp.set_type(props, sp.TMap(sp.TAddress, sp.TBool)); props[sp.sender] = True self.data.buyMap[params.swap_id] = props # Everyone voted yes, execute the buy sp.if sp.len(self.data.buyMap[params.swap_id]) == sp.len(self.data.owners): self.buy_nft(params.swap_id) # Undo a vote for a swap @sp.entry_point def undo_vote_buy(self): pass # Propose selling an objkt at a certain price point @sp.entry_point def propose_sell(self): pass # Vote for a proposal to sell an objkt @sp.entry_point def vote_sell(self):
def Burn(self, params): value = params.value sp.verify(sp.sender == self.data.owner, message="You must be the owner of the contract to burn tokens") owner_account = sp.record(balance=sp.nat( 0), allowances=sp.map(tkey=sp.TAddress, tvalue=sp.TNat)) sp.if self.data.ledger.contains(self.data.owner): owner_account = self.data.ledger[self.data.owner] sp.verify(value <= owner_account.balance, message="Owner balance is too low") owner_account.balance = sp.as_nat(owner_account.balance - value) # subtract allowed amounts by value/len(allowances) sp.for key in owner_account.allowances.keys(): owner_account.allowances[key] = sp.as_nat( owner_account.allowances[key] - value/sp.len(owner_account.allowances)) self.data.ledger[self.data.owner] = owner_account self.data.totalSupply = sp.as_nat(self.data.totalSupply - value) @sp.entry_point def Approve(self, params): spender = params.spender value = params.value sp.if value > self.data.ledger[sp.sender].balance: value = self.data.ledger[sp.sender].balance sp.if sp.sender != spender: src = self.data.ledger[sp.sender] src.allowances[spender] = value self.data.ledger[sp.sender] = src