def ChangePoolSize(self,params):
sp.verify(sp.sender == self.data.administrator)
sp.set_type(params, sp.TRecord(size = sp.TNat))
self.data.PoolSize = params.size
def getDataFromOro(self,params):
sp.set_type(params.entryAddress,sp.TAddress)
errcd = sp.record(uuid=params.uuid,cycleNumber=0)
contract = sp.contract(sp.TRecord(uuid = sp.TNat, cycleNumber = sp.TNat),params.entryAddress).open_some()
sp.if sp.amount == sp.mutez(5000):
sp.transfer(sp.record(uuid=params.uuid,cycleNumber=self.data.cycleNumber),sp.mutez(0),contract)
def transfer(self, params):
sp.verify(~self.data.paused)
sp.set_type(params, self.batch_transfer.get_type())
sp.for transfer in params:
current_from = transfer.from_
if self.config.support_operator:
sp.verify(
(sp.sender == self.data.administrator) |
(current_from == sp.sender) |
self.operator_set.is_member(self.data.operators,
current_from,
sp.sender),
message=self.error_message.not_operator())
else:
sp.verify(
(sp.sender == self.data.administrator) |
(current_from == sp.sender),
message=self.error_message.not_owner())
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")
sp.verify(self.data.tokens.contains(tx.token_id),
message=self.error_message.token_undefined())
# If amount is 0 we do nothing now:
from_user = self.ledger_key.make(current_from, tx.token_id)
sp.verify(
self.data.ledger[from_user].tokens.contains(tx.token_id),
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)
self.data.ledger[from_user].tokens.remove(tx.token_id)
sp.if self.data.ledger.contains(to_user):
self.data.ledger[to_user].tokens.add(tx.token_id)
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 transfer(self, params):
sp.set_type(
params,
sp.TRecord(from_=sp.TAddress, to_=sp.TAddress,
value=sp.TNat)).layout(
("from_ as from", ("to_ as to", "value")))
sender = sp.local("sender", sp.sender)
with sp.if_((self.transfer_presigned(params))):
# Setting sender.value to from_ so call to transfer_helper will be authorized
sender.value = params.from_
sp.verify((sender.value == self.data.administrator) | (
~self.data.paused & (
(params.from_ == sender.value) | (self.data.balances[
params.from_].approvals[sender.value] >= params.value))))
self.addAddressIfNecessary(params.to_)
sp.verify(self.data.balances[params.from_].balance >= params.value)
self.data.balances[params.from_].balance = sp.as_nat(
self.data.balances[params.from_].balance - params.value)
self.data.balances[params.to_].balance += params.value
with sp.if_(((params.from_ != sender.value) &
(self.data.administrator != sender.value))):
self.data.balances[params.from_].approvals[
sender.value] = sp.as_nat(
self.data.balances[params.from_].approvals[sender.value] -
params.value)
def remove_execution_request(self, removal_request):
sp.set_type(removal_request, RemovalRequest.get_type())
signing_payload = RemovalRequest.get_signing_payload(sp.chain_id, sp.self_address, removal_request.timelock_id)
valid_signatures_counter = sp.local('valid_signatures_counter', sp.nat(0))
sp.for operator_public_key in self.data.operator_public_keys:
sp.if sp.check_signature(operator_public_key, removal_request.signatures[sp.hash_key(operator_public_key)], sp.pack(signing_payload)):
valid_signatures_counter.value += 1
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 meta_transfer(self, params):
sp.verify(sp.sender == self.data.administrator)
sp.set_type(params, BatchMetaTransfer.get_type())
sp.for meta_transfer in params:
source_account_key_hash = sp.hash_key(
meta_transfer.from_public_key)
source_account = sp.to_address(
sp.implicit_account(source_account_key_hash))
sp.verify(self.data.nonces.get(
source_account, 0)+1 == meta_transfer.nonce)
packed_data = sp.pack(
BatchMetaTransfer.get_signing_payload(meta_transfer))
sp.verify(sp.check_signature(meta_transfer.from_public_key,
meta_transfer.signature, packed_data), message=ErrorMessage.invalid_signature())
self.data.nonces[source_account] = meta_transfer.nonce
sp.for tx in meta_transfer.txs:
from_user = LedgerKey.make(source_account, tx.token_id)
to_user = LedgerKey.make(tx.to_, tx.token_id)
sp.verify(tx.amount > 0,
message=ErrorMessage.transfer_of_zero())
sp.verify(self.data.ledger[from_user] >= tx.amount,
message=ErrorMessage.insufficient_balance())
self.data.ledger[from_user] = sp.as_nat(
self.data.ledger[from_user] - tx.amount)
self.data.ledger[to_user] = self.data.ledger.get(
to_user, 0) + tx.amount
sp.if self.data.ledger[from_user] == 0:
del self.data.ledger[from_user]
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 _transfer(self, params):
sp.set_type(params,
sp.TRecord(
token_id = sp.TOption(sp.TNat),
token_address = sp.TAddress,
from_ = sp.TAddress,
to_ = sp.TAddress,
amount = sp.TNat
)
)
sp.if params.token_id.is_some():
c = sp.contract(
t = sp.TRecord(
token_id = sp.TNat,
from_ = sp.TAddress,
to_ = sp.TAddress,
amount = sp.TNat
),
address = params.token_address,
entry_point = "transfer"
).open_some()
sp.transfer(
sp.record(
token_id = params.token_id.open_some(),
from_ = params.from_,
to_ = params.to_,
amount = params.amount
),
sp.mutez(0),
c
)
def set_redeem_addresses(self, redeem_addresses):
"""Allows to specify the burn adress for a contract for a specific token, only a token administrator can do this"""
sp.set_type(redeem_addresses, RedeemAddress.get_batch_type())
sp.for redeem_address in redeem_addresses:
administrator_ledger_key = LedgerKey.make(sp.sender, redeem_address.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[redeem_address.token_id].redeem_address = redeem_address.address
def _mint(self, params):
sp.set_type(params,
sp.TRecord(
to_ = sp.TAddress,
amount = sp.TNat,
token_address = sp.TAddress,
token_id = sp.TOption(sp.TNat),
metadata=sp.TOption(sp.TMap(sp.TString, sp.TBytes))
)
)
sp.if params.token_id.is_some():
c = sp.contract(
t = sp.TRecord(
address = sp.TAddress,
amount = sp.TNat,
token_id=sp.TNat,
metadata=sp.TMap(sp.TString, sp.TBytes)
),
address = params.token_address,
entry_point = "mint"
).open_some()
sp.transfer(
sp.record(
address = params.to_,
amount = params.amount,
token_id = params.token_id.open_some(),
metadata = params.metadata.open_some()
),
sp.mutez(0),
c
)
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 accept_bid_for_bot(self, params):
# Make sure that sp.sender has admin access otherwise don't proceed forward
# Make sure that contract isn't paused
sp.set_type(params.token_id, sp.TNat)
sp.set_type(params.nft_amount, sp.TNat)
# Make sure that the NFT token id is already present in the ledger
sp.verify(self.token_id_set.contains(self.data.all_tokens, params.token_id), "TOKEN ID NOT FOUND")
# NFT transfer amount should be 1
sp.verify(params.nft_amount == 1, "NFT AMOUNT OF 1 REQUIRED")
# Make sure that the caller is the owner of NFT token id else throw error
user = self.ledger_key.make(sp.sender, params.token_id)
sp.verify(self.data.ledger.contains(user) == True, "NOT OWNER OF NFT TOKEN ID")
# Make sure their is aleast one bid for NFT token id
sp.verify(sp.len(self.data.bid[params.token_id]) > 0, "NO BIDDER YET")
highest_bidder = sp.local("highest_bidder", sp.record(
has_bid = False,
bidder = sp.address("tz1iLVzBpCNTGz6tCBK2KHaQ8o44mmhLTBio"),
bid_value = sp.mutez(0)
))
# transfer the highest bidder value to the seller account
sp.for bidder in self.data.bid[params.token_id]:
# store highest bidder
sp.if bidder.bid_value > highest_bidder.value.bid_value:
highest_bidder.value = bidder
def transfer(self, params):
sp.set_type(params, sp.TRecord(from_=sp.TAddress, to_=sp.TAddress,
value=sp.TNat)).layout(("from_ as from", ("to_ as to", "value")))
sender = sp.local("sender", sp.sender)
sp.if (self.transfer_presigned(params)):
# Setting sender.value to from_ so call to transfer_helper will be authorized
sender.value = params.from_
def collect_royalties(self, to_):
sp.set_type(to_, sp.TAddress)
accumulated_royalties = self.data.accumulated_royalties[sp.sender]
sp.send(to_, accumulated_royalties)
del self.data.accumulated_royalties[sp.sender]
def add_execution_request(self, execution_request):
sp.set_type(execution_request, ExecutionRequest.get_type())
signing_payload = ExecutionRequest.get_signing_payload(sp.chain_id, sp.self_address, self.data.nonce+sp.nat(1), execution_request.execution_payload)
valid_signatures_counter = sp.local('valid_signatures_counter', sp.nat(0))
sp.for operator_public_key in self.data.operator_public_keys:
sp.if sp.check_signature(operator_public_key, execution_request.signatures[sp.hash_key(operator_public_key)], sp.pack(signing_payload)):
valid_signatures_counter.value += 1
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 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 approve(self, params):
sp.set_type(params, sp.TRecord(spender = sp.TAddress, value = sp.TNat).layout(("spender", "value")))
self.addAddressIfNecessary(sp.sender)
sp.verify(~self.is_paused(), FA12_Error.Paused)
alreadyApproved = self.data.balances[sp.sender].approvals.get(params.spender, 0)
sp.verify((alreadyApproved == 0) | (params.value == 0), FA12_Error.UnsafeAllowanceChange)
self.data.balances[sp.sender].approvals[params.spender] = params.value
def updateLambda(unitParam):
sp.set_type(unitParam, sp.TUnit)
storeContractHandle = sp.contract(sp.TNat, box.address,
'update').open_some()
sp.result([
sp.transfer_operation(newValue, sp.mutez(0), storeContractHandle)
])
def assertTransfer(self, params):
sp.set_type(
params,
sp.TRecord(
from_=sp.TAddress,
to_=sp.TAddress,
# we can assert the role of this operator
operator=sp.TAddress
)
)
sp.if ~self.data.allowlist.contains(params.from_) | self.data.blocklist.contains(params.from_):
# controller should be able to move tokens out of a blocked address
c = sp.contract(
t = sp.TRecord(
role=sp.TNat,
account=sp.TAddress
),
address = sp.sender,
entry_point = "assertRole"
).open_some()
sp.transfer(
sp.record(
role=TOKEN_CONTROLLER_ROLE,
account=params.operator
),
sp.mutez(0),
c
)
def burn(self, params):
sp.set_type(params, sp.TRecord(address=sp.TAddress, value=sp.TNat))
sp.verify(sp.sender == self.data.administrator)
sp.verify(self.data.balances[params.address].balance >= params.value)
self.data.balances[params.address].balance = sp.as_nat(
self.data.balances[params.address].balance - params.value)
self.data.totalSupply = sp.as_nat(self.data.totalSupply - params.value)
def breakGlass(self, newContracts):
sp.set_type(
newContracts,
sp.TRecord(
governorContract=sp.TAddress,
tokenContract=sp.TAddress,
ovenProxyContract=sp.TAddress,
stabilityFundContract=sp.TAddress,
developerFundContract=sp.TAddress,
).layout(("governorContract", ("tokenContract",
("ovenProxyContract",
("stabilityFundContract",
"developerFundContract"))))))
# Can only be called by the multisig.
sp.verify(sp.sender == self.data.multisigAddress, "NOT_MSIG")
targetParam = (newContracts.governorContract,
(newContracts.tokenContract,
(newContracts.ovenProxyContract,
(newContracts.stabilityFundContract,
newContracts.developerFundContract))))
targetContractHandle = sp.contract(
sp.TPair(
sp.TAddress,
sp.TPair(
sp.TAddress,
sp.TPair(sp.TAddress, sp.TPair(sp.TAddress,
sp.TAddress)))),
self.data.targetAddress, 'updateContracts').open_some()
sp.transfer(targetParam, sp.mutez(0), targetContractHandle)
def transfer_presigned(self, params):
sp.set_type(
params,
sp.TRecord(from_=sp.TAddress, to_=sp.TAddress, value=sp.TNat))
params_hash = sp.blake2b(sp.pack(params))
#unsigned = sp.blake2b(mi.operator("SELF; ADDRESS; CHAIN_ID; PAIR; PAIR; PACK", [sp.TPair(sp.TNat, sp.TBytes)], [sp.TBytes])(sp.pair(self.data.counter, params_hash)))
permit_key = sp.pair(params.from_, params_hash)
effective_expiry = sp.local("effective_expiry", 0)
with sp.if_(self.data.permits.contains(permit_key)):
permit_submission_timestamp = self.data.permits[permit_key]
with sp.if_(
self.data.permit_expiries.contains(permit_key)
& self.data.permit_expiries[permit_key].is_some()):
effective_expiry.value = self.data.permit_expiries[
permit_key].open_some()
with sp.else_():
with sp.if_(
self.data.user_expiries.contains(params.from_)
& self.data.user_expiries[params.from_].is_some()):
effective_expiry.value = self.data.user_expiries[
params.from_].open_some()
with sp.else_():
effective_expiry.value = self.data.default_expiry
# Deleting permit regardless of whether or not its expired
with sp.if_(
sp.as_nat(sp.now - permit_submission_timestamp) >=
effective_expiry.value):
# Expired
self.delete_permit(permit_key)
sp.result(sp.bool(False))
with sp.else_():
self.delete_permit(permit_key)
sp.result(sp.bool(True))
with sp.else_():
sp.result(sp.bool(False))
def request_tokens(self, targets):
sp.set_type(targets, sp.TSet(sp.TAddress))
token = sp.contract(self.token_contract.batch_transfer.get_type(),
self.data.token,
entry_point = "transfer").open_some(message = "Incompatible token interface")
targets = targets.elements().map(lambda target: sp.record(to_ = target, token_id = 0, amount = self.data.max_amount))
sp.transfer([sp.record(from_ = sp.to_address(sp.self), txs = targets)], sp.tez(0), token)
def ValidatorOperation(self,params):
sp.set_type(params, sp.TRecord(address = sp.TAddress, Operation = sp.TNat))
sp.verify(sp.sender == self.data.administrator)
sp.if params.Operation == sp.nat(1):
self.data.validator.add(params.address)
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 addProject(self,dao,adminaddress,cat):
sp.set_type(adminaddress, sp.TAddress)
adminaddress=adminaddress
sp.if self.data.addDAOdata.contains(dao):
self.data.project_id +=1
keyindex=self.data.project_id
self.data.addprojectdata[keyindex] = sp.record(proowner=adminaddress,DAO=dao,serialno=keyindex,vote=0,cat=cat)
def OracleExerciseSecurity(self,params):
sp.set_type(params, sp.TRecord(price = sp.TNat, owner = sp.TAddress))
sp.verify(sp.sender == self.data.oracle)
sp.verify(sp.now <= self.data.Securities[params.owner].expiry)
sp.verify(self.data.Securities[params.owner].strikePrice > params.price)
self.data.adminAccount += self.data.Securities[params.owner].adminpayment
Amount = sp.local('Amount',abs(self.data.Securities[params.owner].strikePrice - params.price)*10000000)
Amount.value = Amount.value*self.data.Securities[params.owner].options
CalAmount = sp.local('CalAmount',sp.nat(0))
PoolAmount = sp.local('PoolAmount',self.data.Securities[params.owner].strikePrice*self.data.Securities[params.owner].options*10000000)
PoolAmount.value = abs(PoolAmount.value - self.data.Securities[params.owner].adminpayment)
sp.for i in self.data.Securities[params.owner].pool.keys():
CalAmount.value += (self.data.Securities[params.owner].pool[i]*Amount.value)/(PoolAmount.value)
self.data.LiquidityProvider[i].locked = abs(self.data.LiquidityProvider[i].locked - self.data.Securities[params.owner].pool[i])
self.data.Securities[params.owner].pool[i] = abs(self.data.Securities[params.owner].pool[i] - (self.data.Securities[params.owner].pool[i]*Amount.value)/(PoolAmount.value) )
sp.if self.data.poolSet.contains(i):
self.data.LiquidityProvider[i].amount += self.data.Securities[params.owner].pool[i]
self.data.totalSupply += self.data.Securities[params.owner].pool[i]
