def setPause(self, params):
sp.set_type(params, sp.TBool)
sp.verify(sp.sender == self.data.administrator)
self.data.paused = params
def mutez_transfer(contract, params):
sp.verify(sp.sender == contract.data.administrator)
sp.set_type(params.destination, sp.TAddress)
sp.set_type(params.amount, sp.TMutez)
sp.send(params.destination, params.amount)
def set_administrator(self, params):
sp.verify(self.is_administrator(sp.sender))
self.data.administrator = params
def burnDataToken(self, params): sp.verify(sp.sender == self.data.admin) sp.verify(self.data.tokensMinted.contains(params.token_id)) self.data.tokensMinted.remove(params.token_id)
def transfer(self, params):
sp.verify(self.data.tokensMinted.contains(params.token_id))
sp.verify(self.data.tokenIdToOwner[params.token_id] == sp.sender)
self.data.tokenHolderToID[sp.sender].remove(params.token_id)
sp.if (~ (self.data.ownerToBalance.contains(params.to))):
self.data.tokenHolderToID[params.to] = sp.set([])
def IncreaseCollateral(self,params):
sp.set_type(params, sp.TRecord(amount = sp.TNat))
sp.verify(sp.mutez(params.amount) == sp.amount)
self.data.xtz += params.amount
def UpdateCollateral(self,amount):
sp.verify(sp.sender == self.data.owner)
sp.verify(sp.amount == sp.mutez(0))
sp.verify(sp.balance == sp.mutez(amount))
self.data.xtz = amount
def claimSale(self, params):
sp.verify(sp.sender == self.data.administrator)
sp.verify(sp.balance > sp.mutez(params.amount))
muSharetez = params.amount // 100
self.processSplit(muSharetez)
def unlockAddress(self, params):
sp.verify(sp.sender == self.data.administrator)
sp.verify(self.data.balances.contains(params.address))
self.data.balances[params.address].lock = False
def mint(self, params):
sp.verify(sp.sender == self.data.administrator)
self.checkLimit(params.amount)
self.addAddressIfNecessary(params.toAddr)
self.data.balances[params.toAddr].balance += params.amount
self.data.circulatingSupply += params.amount
def increaseSaleLimit(self, params):
sp.verify(sp.sender == self.data.administrator)
self.checkLimit(params.amount)
self.data.saleLimit += params.amount
def checkLimit(self, amount):
sp.verify(amount + self.data.saleLimit - self.data.soldToken + self.data.circulatingSupply <= self.data.supplyLimit)
def mint(self, params):
sp.set_type(params, sp.TRecord(address=sp.TAddress, value=sp.TNat))
sp.verify(sp.sender == self.data.administrator)
self.addAddressIfNecessary(params.address)
self.data.balances[params.address].balance += params.value
self.data.totalSupply += params.value
def setAdministrator(self, params):
sp.set_type(params, sp.TAddress)
sp.verify(sp.sender == self.data.administrator)
self.data.administrator = params
def offchainSale(self, params):
sp.verify(sp.sender == self.data.saleManager)
sp.if self.data.balances.contains(params.address):
sp.verify(~ self.data.balances[params.address].lock)
def pauseTransfer(self, params):
sp.verify(sp.sender == self.data.administrator)
self.data.transferStatus = False
def mintSale(self, address, nbMutoken):
sp.verify(self.data.soldToken + nbMutoken <= self.data.saleLimit)
self.addAddressIfNecessary(address)
self.data.balances[address].balance += nbMutoken
self.data.circulatingSupply += nbMutoken
self.data.soldToken += nbMutoken
def resumeTransfer(self, params):
sp.verify(sp.sender == self.data.administrator)
self.data.transferStatus = True
def delegate(self, baker):
sp.verify(sp.sender == self.data.owner)
sp.set_delegate(baker)
def pauseSale(self, params):
sp.verify(sp.sender == self.data.administrator)
self.data.saleStatus = False
def WithdrawAdmin(self,params):
sp.verify(sp.sender == self.data.admin)
sp.send(self.data.admin,sp.balance)
def resumeSale(self, params):
sp.verify(sp.sender == self.data.administrator)
self.data.saleStatus = True
def mintDataToken(self, params):
sp.verify(sp.sender == self.data.admin)
sp.verify(~ (self.data.tokensMinted.contains(params.token_id)))
self.data.tokensMinted.add(params.token_id)
sp.if (~ (self.data.ownerToBalance.contains(params.address))):
self.data.tokenHolderToID[params.address] = sp.set([])
def setAdministrator(self, params):
sp.verify(sp.sender == self.data.owner)
self.addAddressIfNecessary(params)
self.data.administrator = params
def approve(self, params): sp.verify(self.data.tokensMinted.contains(params.token_id)) sp.verify(sp.sender == self.data.tokenIdToOwner[params.token_id]) self.data.tokenApprovals[params.token_id] = params.approve_to
def setManager(self, params):
sp.verify(sp.sender == self.data.administrator)
self.addAddressIfNecessary(params)
self.data.saleManager = params
def transfer(self, params):
sp.verify( ~self.is_paused() )
sp.set_type(params, self.batch_transfer.get_type())
sp.for transfer in params:
current_from = transfer.from_
sp.for tx in transfer.txs:
#sp.verify(tx.amount > 0, message = "TRANSFER_OF_ZERO")
if self.config.single_asset:
sp.verify(tx.token_id == 0, "single-asset: token-id <> 0")
if self.config.support_operator:
sp.verify(
(self.is_administrator(sp.sender)) |
(current_from == sp.sender) |
self.operator_set.is_member(self.data.operators,
current_from,
sp.sender,
tx.token_id),
message = self.error_message.not_operator())
else:
sp.verify(
(self.is_administrator(sp.sender)) |
(current_from == sp.sender),
message = self.error_message.not_owner())
sp.verify(self.data.token_metadata.contains(tx.token_id),
message = self.error_message.token_undefined())
# If amount is 0 we do nothing now:
sp.if (tx.amount > 0):
from_user = self.ledger_key.make(current_from, tx.token_id)
sp.verify(
(self.data.ledger[from_user].balance >= tx.amount),
message = self.error_message.insufficient_balance())
to_user = self.ledger_key.make(tx.to_, tx.token_id)
self.data.ledger[from_user].balance = sp.as_nat(
self.data.ledger[from_user].balance - tx.amount)
sp.if self.data.ledger.contains(to_user):
self.data.ledger[to_user].balance += tx.amount
def sale(self, params):
sp.verify(self.data.saleStatus)
sp.if self.data.balances.contains(sp.sender):
sp.verify(~ self.data.balances[sp.sender].lock)
def set_pause(self, params):
sp.verify(self.is_administrator(sp.sender))
self.data.paused = params
def setExpiry(self, params):
sp.set_type(
params,
sp.TRecord(address=sp.TAddress,
seconds=sp.TNat,
permit=sp.TOption(sp.TBytes))).layout(
("address", ("seconds", "permit")))
sp.verify(~self.data.paused)
sp.verify(params.seconds <= self.data.max_expiry,
"MAX_SECONDS_EXCEEDED")
sp.verify_equal(params.address, sp.sender, message="NOT_AUTHORIZED")
with sp.if_(params.permit.is_some()):
some_permit = params.permit.open_some()
sp.verify(
self.data.permits.contains(sp.pair(params.address,
some_permit)),
"PERMIT_NONEXISTENT")
permit_submission_timestamp = self.data.permits[sp.pair(
params.address, some_permit)]
with sp.if_(
self.data.permit_expiries.contains(
sp.pair(params.address, some_permit))
& self.data.permit_expiries[sp.pair(
params.address, some_permit)].is_some()):
permit_expiry = self.data.permit_expiries[sp.pair(
params.address, some_permit)].open_some()
sp.verify(
sp.as_nat(sp.now - permit_submission_timestamp) <
permit_expiry, "PERMIT_REVOKED")
with sp.else_():
with sp.if_(
self.data.user_expiries.contains(params.address)
& self.data.user_expiries[params.address].is_some()):
user_expiry = self.data.user_expiries[
params.address].open_some()
sp.verify(
sp.as_nat(sp.now - permit_submission_timestamp) <
user_expiry, "PERMIT_REVOKED")
with sp.else_():
sp.verify(
sp.as_nat(sp.now - permit_submission_timestamp) <
self.data.default_expiry, "PERMIT_REVOKED")
self.data.permit_expiries[sp.pair(
params.address, some_permit)] = sp.some(params.seconds)
self.data.user_expiries[params.address] = sp.some(params.seconds)
