def default(self, params):
sp.verify(sp.amount == LEADERSHIP_PAYMENT_AMOUNT)
sp.verify(self.data.leadership_start_timestamp.add_seconds(sp.to_int(self.data.countdown_milliseconds/1000)) > sp.now)
self.data.leader = sp.sender
self.data.leadership_start_timestamp = sp.now
balance_weight_tenthtez = sp.fst(sp.ediv(sp.balance-INITIAL_BALANCE,sp.mutez(1)).open_some())/sp.nat(100000) # mutez becomes tenth of a tez
countdown_drop_milliseconds = (COUNTDOWN_DROP_FACTOR+balance_weight_tenthtez)/balance_weight_tenthtez
sp.if self.data.countdown_milliseconds - countdown_drop_milliseconds > sp.to_int(MINIMAL_COUNT_DOWN_MILLISECONDS):
self.data.countdown_milliseconds = sp.as_nat(self.data.countdown_milliseconds - countdown_drop_milliseconds)
def cvrDrop(self, params):
sp.verify(sp.sender == self.data.administrator)
self.checkLimit(params.amount * sp.to_int(sp.len(params.addresses)))
sp.for address in params.addresses:
self.addAddressIfNecessary(address)
self.data.balances[address].balance += params.amount
self.data.circulatingSupply += params.amount
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 getDataMint(self,params):
data = sp.record(price=sp.to_int(self.data.xtzPrice),address=params.address,amount=params.amount)
contract = sp.contract(sp.TRecord( price = sp.TInt,address = sp.TAddress, amount = sp.TInt),sp.sender,entry_point = "OrOMint").open_some()
sp.if sp.amount == sp.mutez(10):
sp.transfer(data,sp.mutez(0),contract)
def putBuyer(self,params):
sp.verify(sp.now < self.data.validation.cycleEnd)
sp.verify(~ self.data.contractBuyer.contains(sp.sender))
price = sp.set([80,90,100,110,120])
duration = sp.set([7,14,21])
sp.verify(price.contains(params.StrikePrice))
sp.verify(params.Options>0)
sp.verify(duration.contains(sp.to_int(params.expire)))
sp.verify(self.data.validation.cycleEnd > sp.now.add_days(sp.to_int(params.expire)))
data = sp.record(Options=abs(params.Options),Ratio=sp.to_int(params.StrikePrice),address=sp.sender,expire=sp.to_int(params.expire))
contract = sp.contract(sp.TRecord(Options = sp.TNat,address = sp.TAddress,Ratio = sp.TInt,expire=sp.TInt),self.data.Oracle,entry_point = "GetputSeller").open_some()
#Oracle Call
sp.transfer(data, sp.mutez(10), contract)
def sellShort(self, params):
sp.set_type(params, sp.TRecord(quantity = sp.TNat, price_buy = sp.TNat, price_sell = sp.TNat))
sp.verify(~self.data.result.is_some())
sp.verify(self.data.sharesShort[sp.sender][params.price_buy] >= sp.to_int(params.quantity))
sp.verify(params.price_sell <= 1000000)
matchPrice = 1000000 - params.price_sell
confirmed = sp.local('confirmed', False)
index = sp.local('index', -1)
sp.for i in self.data.sellLongOrders.keys():
order = self.data.orders[i]
sp.if ~confirmed.value & (order.price == sp.as_nat(matchPrice)) & (order.quantity == params.quantity) & ~(order.creator == sp.sender):
confirmed.value = True
index.value = i
def PurchaseSecurity(self,params):
sp.set_type(params, sp.TRecord(order = sp.TNat , duration = sp.TNat, securityDelegator = sp.TAddress))
duration = sp.set([1,7,14])
sp.verify(sp.sender == self.data.owner)
sp.verify(duration.contains(params.duration))
self.data.Insurance = sp.now.add_days(sp.to_int(params.duration))
self.data.securityDelegator = params.securityDelegator
c = sp.contract(sp.TRecord(xtz = sp.TNat, token = sp.TNat, order = sp.TNat , duration = sp.TNat , spender = sp.TAddress), self.data.oracle, entry_point = "SecuritiesPurchase").open_some()
mydata = sp.record(xtz = self.data.xtz, token = self.data.token, order = params.order , duration = params.duration, spender = self.data.owner)
sp.transfer(mydata, sp.mutez(0), c)
def deposit(self, params):
sp.verify(sp.amount > sp.mutez(0), message = "Deposit too low")
contractbal = sp.ediv(sp.balance, sp.tez(1))
sp.if (contractbal.is_some() ):
bal = sp.fst(contractbal.open_some())
val = sp.split_tokens( sp.amount, self.data.totalTokens, bal)
_natVal = sp.ediv(val, sp.tez(1))
sp.if (_natVal.is_some() ):
natVal = sp.fst(_natVal.open_some())
self.data.withdrawBalances[params] = sp.to_int(natVal)
self.data.totalTokens += natVal
def OraclePurchaseSecurity(self,params):
sp.set_type(params, sp.TRecord(price = sp.TNat, duration = sp.TNat, order = sp.TNat, owner = sp.TAddress, spender = sp.TAddress ))
sp.verify(sp.sender == self.data.oracle)
sp.verify(~self.data.Securities.contains(params.owner))
Deadline = sp.now.add_days(sp.to_int(params.duration))
self.data.Securities[params.owner] = sp.record(strikePrice = params.price, pool = sp.map(),
adminpayment = sp.nat(0), options = params.order, expiry = Deadline
)
TotalAmount = sp.local('TotalAmount',params.price*params.order*abs(10000000))
CollateralValue = sp.local('CollateralValue',sp.nat(0))
self.data.InterestRate[1] = sp.nat(1)
self.data.InterestRate[7] = sp.nat(2)
self.data.InterestRate[14] = sp.nat(4)
PremiumTotal = sp.local('PremiumTotal',params.price*params.order*self.data.InterestRate[params.duration]*abs(100000))
PremiumLiquidity = sp.local('PremiumLiquidity',sp.nat(0))
del self.data.InterestRate[1]
del self.data.InterestRate[7]
del self.data.InterestRate[14]
self.data.adminAccount += params.price*params.order*100000
sp.verify(self.data.totalSupply >= TotalAmount.value)
sp.for i in self.data.poolSet.elements():
self.data.Securities[params.owner].pool[i] = (self.data.LiquidityProvider[i].amount*TotalAmount.value)/(self.data.totalSupply)
self.data.LiquidityProvider[i].locked += (self.data.LiquidityProvider[i].amount*TotalAmount.value)/(self.data.totalSupply)
CollateralValue.value += (self.data.LiquidityProvider[i].amount*TotalAmount.value)/(self.data.totalSupply)
self.data.LiquidityProvider[i].premium += (self.data.LiquidityProvider[i].amount*PremiumTotal.value)/(self.data.totalSupply)
PremiumLiquidity.value += (self.data.LiquidityProvider[i].amount*PremiumTotal.value)/(self.data.totalSupply)
self.data.LiquidityProvider[i].amount = abs(self.data.LiquidityProvider[i].amount - (self.data.LiquidityProvider[i].amount*TotalAmount.value)/(self.data.totalSupply) )
def insertSort(self, param):
self.data.isOpen = False
jx = sp.local('jx', param)
jint = sp.local('jint', sp.to_int(param))
def swap(i):
tempBid = sp.local("tempBid", self.data.bids[nat(i)])
tempAgent = sp.local("tempAgent", self.data.agents[nat(i)])
self.data.bids[nat(i)] = self.data.bids[nat(i - 1)]
self.data.agents[nat(i)] = self.data.agents[nat(i - 1)]
self.data.bids[nat(i - 1)] = tempBid.value
self.data.agents[nat(i - 1)] = tempAgent.value
def nat(x):
return sp.as_nat(x)
sp.while ((nat(jint.value) > 0) & (self.data.bids[nat(jint.value)] >= self.data.bids[nat(jint.value - 1)]) ) :
swap(jint.value)
jint.value -= 1
def getResponseFromHarbinger(self,response):
sp.verify(self.data.admin.contains(sp.source) , "Un-authorized")
sp.set_type(response , sp.TPair(sp.TString , sp.TPair(sp.TTimestamp , sp.TNat)))
currentPrice=sp.local("currentPrice",sp.int(0))
currentPrice = sp.to_int(sp.fst(sp.ediv(sp.snd(sp.snd(response)) , sp.nat(1000)).open_some()))
currentCycle = sp.local("currentCycle" ,sp.int(0))
currentCycle = sp.fst(sp.ediv(sp.level,self.data.blocksPerCycle).open_some())
sp.verify(~self.data.cycleData.contains(currentCycle+self.data.stakingPeriod))
rangeMap = sp.local("rangeMap" , sp.map(tkey = sp.TPair(sp.TInt, sp.TInt) , tvalue = sp.TMutez))
iterator = sp.local("iterator" , sp.int(0))
sp.while iterator.value<=self.data.rangeEnd:
sp.if iterator.value+self.data.rangeStep<=self.data.rangeEnd:
rangeMap.value[sp.pair(iterator.value,iterator.value+self.data.rangeStep)] =sp.mutez(0)
rangeMap.value[(sp.int(-1)*(iterator.value+self.data.rangeStep),sp.int(-1)*iterator.value)] =sp.mutez(0)
def create_certificate(self, params):
# 0) verify that lock period is not more than 2 years
sp.verify(params.months < 25)
# 1) get tez value
mintAmount = sp.split_tokens(sp.amount, 100, 100)
coins = sp.ediv(mintAmount, sp.mutez(1) )
principal = sp.to_int( sp.fst(coins.open_some()) )
# 2) get timestamp
end_time = sp.now.add_days(params.months*30)
# 3) calculate payout
w = sp.local('w', 1)
y = sp.local('y', 0)
sp.while y.value < params.months:
w.value = 10033*w.value
y.value = y.value + 1
def toInt(self):
sp.verify(
sp.to_int(self.data.fr) ==
35115637951021136697019058358166656987035571271296265805438287419849817743725,
message="Failed to cast field element Fr to Int")
def getPeriod(self):
y = sp.local('y', self.data.periods)
sp.if sp.now > self.data.start.add_seconds(sp.to_int(self.data.duration)):
y.value = self.data.periods
def closeAuction(self, param):
sp.if ( sp.len(self.data.bids) > 0 ) :
lenCtr = sp.local("lenctr", sp.len(self.data.ctrs))
self.data.ctrs[lenCtr.value] = 0
i = sp.local('i', 0)
jc = sp.local('jc', 0)
price_i = sp.local("price_i", 0)
oneNat = sp.as_nat(1)
sp.while ( (i.value < lenCtr.value) & (i.value < sp.len(self.data.bids)) ):
price_i.value = 0
jc.value = i.value + oneNat
sp.while ( jc.value < (lenCtr.value + 1) ):
price_i.value = price_i.value + (self.data.bids[jc.value] * (self.data.ctrs[sp.as_nat(sp.to_int(jc.value) - 1)] - self.data.ctrs[jc.value]))
jc.value += 1
self.data.prices[i.value] = price_i.value
i.value += 1
del self.data.ctrs[lenCtr.value]
def withdraw(self, params):
sp.verify(self.data.leader == sp.sender)
sp.verify(self.data.leadership_start_timestamp.add_seconds(sp.to_int(self.data.countdown_milliseconds/1000)) < sp.now)
sp.send(sp.sender, sp.balance)
scaled_up_intrest = w.value
u = sp.local('u', 1)
v = sp.local('v', 0)
sp.while v.value < params.months:
u.value = 10000*u.value
v.value = v.value + 1
scale_factor = u.value
scaled_stake = principal*(scaled_up_intrest - scale_factor)
x = sp.as_nat(scaled_stake)/sp.as_nat(scale_factor)
stake = sp.to_int(x)
# 3) get highest token_index
token_id = self.data.highestTokenIndex
# 4) mint certificate
sp.verify(~ self.token_id_set.contains(self.data.all_tokens,
token_id),
"NFT-asset: cannot mint twice same token")
user = self.ledger_key.make(sp.sender, token_id)
self.token_id_set.add(self.data.all_tokens, token_id)
sp.if self.data.ledger.contains(user):
def setManager(self, params):
sp.verify(sp.sender == self.data.administrator)
self.addAddressIfNecessary(params)
self.data.saleManager = params
@sp.entry_point
def getManager(self, params):
sp.transfer(self.data.saleManager, sp.tez(0), sp.contract(sp.TAddress, params.target).open_some())
@sp.entry_point
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)
natMutez = sp.fst(sp.ediv(sp.amount, sp.mutez(1)).open_some())
intMutez = sp.to_int(natMutez)
self.mintSale(sp.sender, intMutez * self.data.ratio)
@sp.entry_point
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)
self.mintSale(params.address, params.amount)
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 __init__(self, value):
self.init(storedValue=sp.to_int(value))
def withdraw(self):
sp.verify(self.data.balances.contains(sp.sender))
sp.send(sp.sender,sp.tez(1))
self.data.balances[sp.sender].balance = sp.to_int(self.data.balances[sp.sender].balance % 10000)
sp.verify(params.price_sell <= 1000000)
matchPrice = 1000000 - params.price_sell
confirmed = sp.local('confirmed', False)
index = sp.local('index', -1)
sp.for i in self.data.sellLongOrders.keys():
order = self.data.orders[i]
sp.if ~confirmed.value & (order.price == sp.as_nat(matchPrice)) & (order.quantity == params.quantity) & ~(order.creator == sp.sender):
confirmed.value = True
index.value = i
sp.if confirmed.value:
order = self.data.orders[index.value]
sp.send(order.creator, sp.mutez((order.price * order.quantity) // 10))
sp.send(sp.sender, sp.mutez((params.price_sell * params.quantity) // 10))
self.data.sharesLong[order.creator][order.price] -= sp.to_int(order.quantity)
self.data.sharesShort[sp.sender][params.price_buy] -= sp.to_int(params.quantity)
del self.data.orders[index.value]
del self.data.sellLongOrders[index.value]
sp.else:
self.data.uuid += 1
self.data.sellShortOrders[self.data.uuid] = True
self.data.orders[self.data.uuid] = sp.record(position = Position.Short, creator = sp.sender, priceBuy = params.price_buy, price = params.price_sell, quantity = params.quantity)
@sp.entry_point
def sellLong(self, params):
sp.set_type(params, sp.TRecord(quantity = sp.TNat, price_buy = sp.TNat, price_sell = sp.TNat))
sp.verify(~self.data.result.is_some())
sp.verify(self.data.sharesLong[sp.sender][params.price_buy] >= sp.to_int(params.quantity))
sp.verify(params.price_sell <= 1000000)
