def checkRedeem(self, address): sp.set_type(address, sp.TAddress) contract = sp.contract(sp.TPair(sp.TAddress, sp.TContract( sp.TBool)), self.data.contract, entry_point="hasRedeemed").open_some() payload = sp.pair(address, sp.contract( sp.TBool, sp.self_address, entry_point="callback").open_some()) sp.transfer(payload, 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 fetchPriceFromHarbinger(self,harbingerContractAddress , asset , targetAddress): contractParams = sp.contract(sp.TPair(sp.TString , sp.TContract(sp.TPair(sp.TString , sp.TPair(sp.TTimestamp , sp.TNat)))) , harbingerContractAddress , entry_point="get").open_some() callBack = sp.contract(sp.TPair(sp.TString , sp.TPair(sp.TTimestamp , sp.TNat)) , targetAddress , entry_point="getResponseFromHarbinger").open_some() dataToBeSent = sp.pair(asset , callBack) sp.transfer(dataToBeSent , sp.mutez(0) , contractParams)
def sendNft(self, params): sp.set_type( params, sp.TRecord(ticket_id=sp.TNat, send_to=sp.TContract(sp.TTicket(sp.TNat)))) sp.verify(sp.sender == self.data.admin) my_ticket, new_map = sp.get_and_update(self.data.tickets, params.ticket_id, sp.none) sp.verify(my_ticket.is_some(), "Ticket does not exist") self.data.tickets = new_map sp.transfer(my_ticket.open_some(), sp.mutez(0), params.send_to)
def get(self, requestPair): sp.set_type(requestPair, sp.TPair(sp.TString, sp.TContract(sp.TPair(sp.TString, sp.TPair(sp.TTimestamp, sp.TNat))))) # Destructure the arguments. requestedAsset = sp.compute(sp.fst(requestPair)) callback = sp.compute(sp.snd(requestPair)) # Verify this normalizer has data for the requested asset. sp.verify( self.data.assetMap.contains(requestedAsset), message="bad request" ) # Callback with the requested data. assetData = self.data.assetMap[requestedAsset] normalizedPrice = assetData.computedPrice lastUpdateTime = assetData.lastUpdateTime callbackParam = (requestedAsset, (lastUpdateTime, normalizedPrice)) sp.transfer(callbackParam, sp.mutez(0), callback)
def getAddressInfoFromRegistry(self, params): # type of response tkResponse = sp.TRecord( name = sp.TString, info = sp.TRecord( name = sp.TString, owner = sp.TAddress, resolver = sp.TAddress, registeredAt = sp.TTimestamp, registrationPeriod = sp.TInt, modified = sp.TBool)) # callback handle for the receiver entrypoint kResponse = sp.contract(tkResponse, sp.to_address(sp.self), entry_point = "recvAddressInfo").open_some() # type of request tkRequest = sp.TRecord(addr = sp.TAddress, k = sp.TContract(tkResponse)) kRequest = sp.contract(tkRequest, self.data.registry, entry_point = "sendAddressInfo").open_some() sp.transfer(sp.record(addr = params.addr, k = kResponse), sp.mutez(0), kRequest)
def sendQuery(self, params): rtype = sp.TRecord( currencyPair = sp.TString, value = sp.TNat, precision = sp.TNat, timestamp = sp.TTimestamp, source = sp.TString) ptype = sp.TRecord( currencyPair = sp.TString, callback = sp.TContract(rtype) ) getHandle = sp.contract(ptype, self.data.oracle, entry_point = "processDataRequest").open_some() args = sp.record( currencyPair = params.currencyPair, callback = sp.contract(rtype, sp.to_address(sp.self), entry_point = "receiveData").open_some() ) sp.transfer(args, sp.tez(1000), getHandle)
def buy_powerup(self, powerup): # modify data_type to also hold another variable called cryptobot_address. data_type = sp.TRecord(powerup=sp.TString, cryptobot_contract=sp.TContract( sp.TRecord(power=sp.TString, duration=sp.TNat))) market_contract = sp.contract( data_type, self.data.market_address).open_some() self.data.mutez_points -= sp.mutez(3000) # define self_contract - # 1. Accepts a record with two variables - power(string), duration(nat) # 2. Points to the Cryptobot( use sp.to_address() ) # 3. Specifies receive_powerup entry point self_contract = sp.contract(sp.TRecord(power=sp.TString, duration=sp.TNat), sp.to_address( sp.self), "receive_powerup").open_some() # modify data_to_be_sent to also hold cryptobot_contract which is assigned self_contract data_to_be_sent = sp.record( powerup=powerup, cryptobot_contract=self_contract) sp.transfer(data_to_be_sent, sp.mutez(0), market_contract)
def entry_point_type(): return sp.TRecord( callback = sp.TContract(Balance_of.response_type()), requests = sp.TList(Balance_of.request_type()) ).layout(("requests", "callback"))
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)) sp.else: 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 = 0)) res = sp.local("responses", params.requests.map(f_process_request)) destination = sp.set_type_expr(params.callback, sp.TContract(Balance_of.response_type())) sp.transfer(res.value, sp.mutez(0), destination) @sp.entry_point def update_operators(self, params): sp.set_type(params, sp.TList( sp.TVariant( add_operator = self.operator_param.get_type(), remove_operator = self.operator_param.get_type()))) if self.config.support_operator: sp.for update in params: with update.match_cases() as arg: with arg.match("add_operator") as upd: sp.verify((upd.owner == sp.sender) | (self.is_administrator(sp.sender))) self.operator_set.add(self.data.operators,
def run(self, x): tk = sp.TRecord(k = sp.TContract(sp.TBool), x = sp.TNat) params = sp.record(k = sp.self_entry_point("receiveResult"), x = x) sp.transfer(params, sp.mutez(0), sp.contract(tk, self.data.checkSig).open_some())
def get_leader(self, params): destination = sp.set_type_expr(params.callback, sp.TContract(sp.TAddress)) sp.transfer(self.data.leader, sp.mutez(0), destination)
def get_type(): return sp.TRecord( requests = sp.TList(LedgerKey.get_type()), callback = sp.TContract(BalanceOfRequest.get_response_type()) ).layout(("requests", "callback"))
def is_operator_request_type(): return sp.TRecord( operator = Operator_param.get_type(), callback = sp.TContract(Operator_param.is_operator_response_type()) )
def is_operator_request_type(self): return sp.TRecord( operator = self.get_type(), callback = sp.TContract(self.is_operator_response_type()))
def get_leadership_start_timestamp(self, params): destination = sp.set_type_expr(params.callback, sp.TContract(sp.TTimestamp)) sp.transfer(self.data.leadership_start_timestamp, sp.mutez(0), destination)
def get_countdown_milliseconds(self, params): destination = sp.set_type_expr(params.callback, sp.TContract(sp.TNat)) sp.transfer(self.data.countdown_milliseconds, sp.mutez(0), destination)
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)) sp.else: 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 = 0)) res = sp.local("responses", params.requests.map(f_process_request)) destination = sp.set_type_expr(params.callback, sp.TContract(Balance_of.response_type())) sp.transfer(res.value, sp.mutez(0), destination) @sp.offchain_view(pure = True) def get_balance(self, req): """This is the `get_balance` view defined in TZIP-12.""" sp.set_type( req, sp.TRecord( owner = sp.TAddress, token_id = sp.TNat ).layout(("owner", "token_id"))) 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.result(self.data.ledger[user].balance)
@sp.entry_point 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)) destination = sp.set_type_expr(params.callback, sp.TContract(BalanceOf.response_type())) sp.transfer(res.value.rev(), sp.mutez(0), destination) @sp.entry_point def nonce_of(self, params): res = sp.local("responses", []) sp.set_type(res.value, NonceOf.response_type()) sp.for request in params.requests: nonce = self.data.nonces[request] res.value.push(sp.record(owner=request, nonce=nonce)) destination = sp.set_type_expr(params.callback, sp.TContract(NonceOf.response_type())) sp.transfer(res.value.rev(), sp.mutez(0), destination) class ViewConsumer(sp.Contract):
def get_type(): """Returns the balance_of type, layouted""" return sp.TRecord( requests = sp.TList(LedgerKey.get_type()), callback = sp.TContract(BalanceOf.get_response_type()) ).layout(("requests", "callback"))
def permissions_descriptor(self, params): sp.set_type(params, sp.TContract( self.permissions_descriptor_.get_type())) v = self.permissions_descriptor_.make() sp.transfer(v, sp.mutez(0), params)
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)) destination = sp.set_type(params.callback, sp.TContract(Balance_of.response_type())) sp.transfer(res.value.rev(), sp.mutez(0), destination) @sp.entry_point def total_supply(self, params): sp.verify( ~self.data.paused ) res = sp.local("responses", []) sp.set_type(res.value, Total_supply.response_type()) sp.for req in params.token_ids: res.value.push( sp.record( token_id = req, total_supply = self.data.tokens[req].total_supply)) destination = sp.set_type(params.callback, sp.TContract(Total_supply.response_type())) sp.transfer(res.value.rev(), sp.mutez(0), destination)
def token_metadata_registry(self, params): sp.verify(~self.data.paused) sp.set_type(params, sp.TContract(sp.TAddress)) sp.transfer(sp.to_address(sp.self), sp.mutez(0), params)
def get_request_type(): return sp.TRecord(token_ids = sp.TList(sp.TNat), callback = sp.TContract(RedeemAddress.get_batch_type())).layout(("token_ids", "callback"))