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