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"))
