def update_operators(self, params):
sp.set_type(
params,
sp.TList(
sp.TVariant(
add_operators = sp.TList(sp.TRecord(
owner = sp.TAddress,
operator = sp.TAddress
)),
remove_operators = sp.TList(sp.TRecord(
owner = sp.TAddress,
operator = sp.TAddress
))
)
)
)
sp.if self.data.operable:
sp.for update in params:
with update.match_cases() as arg:
with arg.match("add_operators") as add_operators:
sp.for upd in add_operators:
sp.verify(
(upd.owner == sp.sender) |
(self.is_controller(sp.sender))
)
self.data.ledger[upd.owner].operators.add(upd.operator)
with arg.match("remove_operators") as remove_operators:
sp.for upd in remove_operators:
sp.verify(
(upd.owner == sp.sender) |
(self.is_controller(sp.sender))
)
self.data.ledger[upd.owner].operators.remove(upd.operator)
def runLambda(self, lambdaToExecute):
sp.set_type(lambdaToExecute,
sp.TLambda(sp.TUnit, sp.TList(sp.TOperation)))
# Can only be called by the DAO.
sp.verify(sp.sender == self.data.daoAddress, "NOT_DAO")
# Execute Request
operations = lambdaToExecute(sp.unit)
sp.set_type(operations, sp.TList(sp.TOperation))
sp.add_operations(operations)
def token_metadata(self, params):
sp.verify( ~self.is_paused() )
sp.set_type(params,
sp.TRecord(
token_ids = sp.TList(sp.TNat),
handler = sp.TLambda(
sp.TList(self.token_meta_data.get_type()),
sp.TUnit)
).layout(("token_ids", "handler")))
def f_on_request(req):
self.token_meta_data.set_type_and_layout(self.data.token_metadata[req])
sp.result(self.data.token_metadata[req])
sp.compute(params.handler(params.token_ids.map(f_on_request)))
def get_type():
return sp.TRecord(
auction_id_start = sp.TNat,
token_ids = sp.TList(sp.TNat)
).layout(
("auction_id_start","token_ids")
)
def transfer(self, params):
sp.verify( ~self.data.paused )
sp.set_type(params, sp.TList(Transfer.get_type()))
sp.for transfer in params:
Transfer.set_type_and_layout(transfer)
from_user = Ledger_key.make(Transfer.get_from(transfer),
Transfer.get_token_id(transfer))
to_user = Ledger_key.make(Transfer.get_to(transfer),
Transfer.get_token_id(transfer))
if support_operator:
sp.verify(
(sp.sender == self.data.administrator) |
(Transfer.get_from(transfer) == sp.sender) |
self.data.ledger[from_user].operators.contains(sp.sender))
else:
sp.verify(
(sp.sender == self.data.administrator) |
(Transfer.get_from(transfer) == sp.sender))
sp.verify(
self.data.ledger[from_user].balance
>= Transfer.get_amount(transfer))
self.data.ledger[from_user].balance = sp.as_nat(
self.data.ledger[from_user].balance - Transfer.get_amount(transfer))
sp.if self.data.ledger.contains(to_user):
self.data.ledger[to_user].balance += Transfer.get_amount(transfer)
def permit(self, params):
sp.set_type(
params,
sp.TList(sp.TPair(sp.TKey, sp.TPair(sp.TSignature, sp.TBytes))))
sp.verify(~self.data.paused)
with sp.for_('permit', params) as permit:
params_hash = sp.snd(sp.snd(permit))
unsigned = sp.pack(
sp.pair(sp.pair(sp.chain_id, sp.self_address),
sp.pair(self.data.counter, params_hash)))
pk_address = sp.to_address(
sp.implicit_account(sp.hash_key(sp.fst(permit))))
permit_key = sp.pair(pk_address, params_hash)
permit_exists = self.data.permits.contains(permit_key)
effective_expiry = self.getEffectiveExpiry(
sp.pair(pk_address, params_hash))
permit_submission_timestamp = self.data.permits[permit_key]
sp.verify(
~(permit_exists &
(sp.as_nat(sp.now - permit_submission_timestamp) <
effective_expiry)), sp.pair("DUP_PERMIT", params_hash))
sp.verify(
sp.check_signature(sp.fst(permit), sp.fst(sp.snd(permit)),
unsigned), sp.pair("MISSIGNED", unsigned))
self.data.permits[sp.pair(pk_address, params_hash)] = sp.now
self.data.counter = self.data.counter + 1
def vest(self, params):
sp.set_type(
params,
sp.TList(
sp.TRecord(
schedule_name = sp.TString,
beneficiery = sp.TAddress,
start = sp.TTimestamp,
end = sp.TTimestamp,
cliff = sp.TTimestamp,
vesting_amount = sp.TNat,
token_address = sp.TAddress,
token_id = sp.TOption(sp.TNat),
metadata=sp.TOption(sp.TMap(sp.TString, sp.TBytes))
)
)
)
sp.for schedule in params:
self._vest(schedule)
self._mint(
sp.record(
to_ = sp.self_address,
amount = schedule.vesting_amount,
token_id = schedule.token_id,
token_address = schedule.token_address,
metadata = schedule.metadata
)
)
def execute_timelocks(self, timelock_ids):
sp.set_type(timelock_ids, sp.TList(sp.TNat))
sp.for timelock_id in timelock_ids:
timelocked_execution_request = self.data.timelocked_execution_requests[timelock_id]
sp.verify(timelocked_execution_request.creation_timestamp.add_seconds(sp.to_int(self.data.timelock_seconds)) < sp.now)
sp.add_operations(timelocked_execution_request.execution_request.execution_payload(sp.unit).rev())
del self.data.timelocked_execution_requests[timelock_id]
def cleanup_nonce(self, params):
# only admin can cleanup nonces
sp.verify(sp.sender == self.data.administrator)
sp.set_type(params, sp.TList(sp.TAddress))
sp.for address in params:
del self.data.nonces[address]
def __init__(self, oracles, admin, spare, min_lock, cryptos_symbols, timelocks):
open_pool_data = {
'cryptos': sp.TMap(sp.TString, sp.TString),
'amount': sp.TMutez,
'timestamp': sp.TTimestamp,
'timelock': sp.TTimestamp,
'dips': sp.TMap(sp.TNat, sp.TRecord(amount = sp.TMutez, sent = sp.TBool))
}
swap_pool_data = {
'address': sp.TAddress,
'amount': sp.TMutez,
'crypto': sp.TString,
'rate': sp.TMutez,
'timestamp': sp.TTimestamp,
'timelock': sp.TTimestamp,
'swaps': sp.TList(sp.TNat),
'swapped': sp.TBool,
'settled': sp.TMutez
}
self.init(
spare=spare,
admin=admin,
oracles = oracles,
accepted_cryptos = cryptos_symbols,
min_lock = min_lock,
timelocks = timelocks,
pool_counter=sp.nat(0),
swap_counter=sp.nat(0),
open_pool = sp.map(tkey=sp.TNat, tvalue=sp.TRecord(**open_pool_data)),
swap_pool = sp.big_map(tkey=sp.TNat, tvalue=sp.TRecord(**swap_pool_data)),
closed_pool = sp.big_map(tkey=sp.TNat, tvalue=sp.TRecord(**open_pool_data))
)
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),
message = self.error_message.not_admin_or_operator()
)
self.operator_set.add(self.data.operators,
upd.owner,
upd.operator,
upd.token_id)
with arg.match("remove_operator") as upd:
sp.verify(
(upd.owner == sp.sender) | self.is_administrator(sp.sender),
message = self.error_message.not_admin_or_operator()
)
self.operator_set.remove(self.data.operators,
upd.owner,
upd.operator,
upd.token_id)
def initialise_token(self, token_ids):
"""Initialise the token with the required additional token context, can only be called once per token and only one of its admin can call this"""
sp.set_type_expr(token_ids, sp.TList(sp.TNat))
sp.for token_id in token_ids:
sp.verify((~self.data.token_context.contains(token_id)), message = TZWFA2ErrorMessage.TOKEN_EXISTS)
administrator_ledger_key = LedgerKey.make(sp.sender, token_id)
sp.verify(self.data.administrators.get(administrator_ledger_key, sp.nat(0))==AdministratorState.IS_ADMIN, message = AdministrableErrorMessage.NOT_ADMIN)
self.data.token_context[token_id] = sp.record(total_minted=0, total_burned=0, redeem_address=NULL_ADDRESS, is_paused=False)
def unpause(self, token_ids):
"""Allows to unpause tokens, only a token administrator can do this"""
sp.set_type(token_ids, sp.TList(sp.TNat))
sp.for token_id in token_ids:
administrator_ledger_key = LedgerKey.make(sp.sender, token_id)
sp.verify(self.data.administrators.get(administrator_ledger_key, sp.nat(0))==AdministratorState.IS_ADMIN, message = AdministrableErrorMessage.NOT_ADMIN)
token_context = self.data.token_context[token_id]
token_context.is_paused = False
self.data.token_context[token_id] = token_context
def get_transfer_type():
tx_type = sp.TRecord(to_=sp.TAddress,
token_id=sp.TNat,
amount=sp.TNat).layout(("to_", ("token_id", "amount")))
return sp.TRecord(from_public_key=sp.TKey,
nonce=sp.TNat,
signature=sp.TSignature,
txs=sp.TList(tx_type)).layout(("from_public_key", ("signature", ("nonce", "txs"))))
def get_transfer_type():
tx_type = sp.TRecord(to_=sp.TAddress,
token_id=sp.TNat,
amount=sp.TNat).layout(
("to_", ("token_id", "amount"))
)
return sp.TRecord(from_=sp.TAddress,
txs=sp.TList(tx_type)).layout(
("from_", "txs"))
def __init__(self, admin):
self.init(
admin = admin,
uuid =0,
adminBalance =sp.mutez(0),
oracleAddress = sp.address("KT1NN7B3Wc5vb93wL87Fsu1HJepLkCU5JRHM"),
# amount in mutez
betSize = sp.map({5:5000000,10:3000000,15:1000000}),
earnedAmount = 0,
tempData = sp.map(tkey=sp.TNat,tvalue=sp.TRecord(seed=sp.TNat,betType=sp.TNat,sender=sp.TAddress)),
tempCompleteBetData = sp.map(tkey=sp.TNat,tvalue=sp.TRecord(betType=sp.TNat,betId=sp.TNat)),
# yields are multiplied by 100 to support 2 decimal places
yields = sp.map({5:50,10:75,15:100}),
betData = sp.map({
5:sp.map(tkey=sp.TNat,tvalue= sp.TRecord(seed=sp.TNat,senderList=sp.TList(sp.TAddress))),
10:sp.map(tkey=sp.TNat,tvalue= sp.TRecord(seed=sp.TNat,senderList=sp.TList(sp.TAddress))),
15:sp.map(tkey=sp.TNat,tvalue= sp.TRecord(seed=sp.TNat,senderList=sp.TList(sp.TAddress)))
})
)
def __init__(self, manager, spare):
self.init(
certifiers=sp.map(tkey=sp.TString, tvalue=sp.TAddress),
products=sp.big_map(
tkey=sp.TString,
tvalue=sp.TRecord(**{'certifier':sp.TString,
'metahash':sp.TList(sp.TMap(sp.TString, sp.TString)), 'lookups':sp.TNat})),
manager=manager,
spare=spare
)
def get_signing_payload(batch_meta_transfer):
tx_type = sp.TRecord(to_=sp.TAddress,
token_id=sp.TNat,
amount=sp.TNat).layout(("to_", ("token_id", "amount")))
transfer_type = sp.TRecord(from_public_key=sp.TKey,
nonce=sp.TNat,
txs=sp.TList(tx_type)).layout(("from_public_key", ("nonce", "txs")))
signing_payload = sp.record(from_public_key=batch_meta_transfer.from_public_key,
nonce=batch_meta_transfer.nonce, txs=batch_meta_transfer.txs)
return sp.set_type_expr(signing_payload, transfer_type)
def get_transfer_type(self):
tx_type = sp.TRecord(to_=sp.TAddress,
token_id=token_id_type)
if self.config.force_layouts:
tx_type = tx_type.layout(
("to_", "token_id")
)
transfer_type = sp.TRecord(from_=sp.TAddress,
txs=sp.TList(tx_type)).layout(
("from_", "txs"))
return transfer_type
def get_type():
"""Returns a single transfer type, layouted"""
tx_type = sp.TRecord(to_ = sp.TAddress,
token_id = sp.TNat,
amount = sp.TNat).layout(
("to_", ("token_id", "amount"))
)
transfer_type = sp.TRecord(from_ = sp.TAddress,
txs = sp.TList(tx_type)).layout(
("from_", "txs"))
return transfer_type
def delete_permits(self, permit_keys):
sp.set_type(permit_keys, sp.TList(sp.TPair(sp.TAddress, sp.TBytes)))
effective_expiry = sp.local("effective_expiry", 0)
sp.for permit_key in permit_keys:
permit_exists = self.data.permits.contains(permit_key)
sp.verify(permit_exists, sp.pair(
"NO_PERMIT_TO_DELETE", permit_key))
effective_expiry = self.getEffectiveExpiry(permit_key)
permit_submission_timestamp = self.data.permits[permit_key]
sp.verify(sp.as_nat(sp.now - permit_submission_timestamp) >= effective_expiry,
sp.pair("PERMIT_NOT_EXPIRED", permit_key))
self.delete_permit(permit_key)
def mint_hDAO(self, params):
c = sp.contract(
sp.TList(
sp.TRecord(
to_=sp.TAddress,
amount=sp.TNat
)),
self.data.hdao,
entry_point = "hDAO_batch").open_some()
sp.transfer(
params,
sp.mutez(0),
c)
def update_operators(self, params):
sp.set_type(params, sp.TList(
sp.TVariant(
Add_operator = Operator_param.get_type(),
Remove_operator = Operator_param.get_type())))
if support_operator:
sp.for update in params:
sp.if update.is_variant("Add_operator"):
upd = update.open_variant("Add_operator")
self.make_operator_update(
upd,
Ledger_value.add_operator)
sp.else:
upd = update.open_variant("Remove_operator")
self.make_operator_update(
upd,
Ledger_value.remove_operator)
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:
sp.if update.is_variant("add_operator"):
upd = update.open_variant("add_operator")
sp.verify((upd.owner == sp.sender) |
(sp.sender == self.data.administrator))
self.operator_set.add(self.data.operators,
upd.owner,
upd.operator)
sp.else:
upd = update.open_variant("remove_operator")
sp.verify((upd.owner == sp.sender) |
(sp.sender == self.data.administrator))
self.operator_set.remove(self.data.operators,
upd.owner,
upd.operator)
def permit(self, params):
sp.set_type(params, sp.TList(
sp.TPair(sp.TKey, sp.TPair(sp.TSignature, sp.TBytes))))
sp.for permit in params:
public_key = sp.fst(permit)
signature = sp.fst(sp.snd(permit))
params_hash = sp.snd(sp.snd(permit))
#unsigned = sp.blake2b(mi.operator("SELF; ADDRESS; CHAIN_ID; PAIR; PAIR; PACK", [sp.TPair(sp.TNat, sp.TBytes)], [sp.TBytes])(sp.pair(self.data.permit_data.counter, params_hash)))
unsigned = sp.pack(sp.pair(sp.pair(sp.chain_id, sp.self_address), sp.pair(
self.data.permit_data.counter, params_hash)))
pk_address = sp.to_address(
sp.implicit_account(sp.hash_key(public_key)))
permit_key = sp.pair(pk_address, params_hash)
permit_exists = self.data.permit_data.permits.contains(permit_key)
permit_submission_timestamp = self.data.permit_data.permits[permit_key]
effective_expiry = self.getEffectiveExpiry(permit_key)
sp.verify(~ (permit_exists & (sp.as_nat(sp.now - permit_submission_timestamp) < effective_expiry)),
sp.pair(self.error_message.duplicate_permit(), params_hash))
sp.verify(sp.check_signature(public_key, signature, unsigned), sp.pair(self.error_message.permit_missigned(), unsigned))
self.data.permit_data.permits[permit_key] = sp.now
self.data.permit_data.counter = self.data.permit_data.counter + 1
def fa2_transfer(self, fa2, from_, to_, objkt_id, objkt_amount):
c = sp.contract(sp.TList(sp.TRecord(from_=sp.TAddress, txs=sp.TList(sp.TRecord(amount=sp.TNat, to_=sp.TAddress, token_id=sp.TNat).layout(("to_", ("token_id", "amount")))))), fa2, entry_point='transfer').open_some()
sp.transfer(sp.list([sp.record(from_=from_, txs=sp.list([sp.record(amount=objkt_amount, to_=to_, token_id=objkt_id)]))]), sp.mutez(0), c)
def get_type(self):
return sp.TList(self.get_transfer_type())
def entry_point_type():
return sp.TRecord(
callback = sp.TContract(Balance_of.response_type()),
requests = sp.TList(Balance_of.request_type())
).layout(("requests", "callback"))
def response_type():
return sp.TList(
sp.TRecord(
request = Balance_of.request_type(),
balance = sp.TNat).layout(("request", "balance")))
def get_type():
return sp.TList(
sp.TVariant(
add_operator = UpdateOperatorsRequest.get_operator_param_type(),
remove_operator = UpdateOperatorsRequest.get_operator_param_type())
)
