def vestedAmount(self, params):
vested_amount = self._vested(sp.record(
beneficiery= params.beneficiery, schedule_name= params.schedule_name))
sp.transfer(
vested_amount,
sp.tez(0), sp.contract(sp.TNat, params.target).open_some())
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 arguments_for_balance_of(receiver, reqs):
return (sp.record(
callback = sp.contract(
Balance_of.response_type(),
sp.contract_address(receiver),
entry_point = "receive_balances").open_some(),
requests = reqs))
def initiateWait(self, _amount, _hashedSecret, _refundTimestamp, initiator_eth_addr):
self.contractIsActive()
self.isInitiable(_hashedSecret, _refundTimestamp)
contract = sp.contract(self.transfer.get_type(), self.data.fa2, "transfer").open_some()
sp.transfer([sp.record(from_=sp.sender, txs=[sp.record(to_=sp.self_address, token_id=self.data.tokenID, amount=_amount)])],sp.mutez(0), contract)
self.data.swaps[_hashedSecret] = sp.record(hashedSecret=_hashedSecret, initiator_eth_addr=initiator_eth_addr, initiator=sp.sender,
participant=sp.sender, refundTimestamp=_refundTimestamp, value=_amount, state=State.Waiting)
def requestDataFromOrO(self, params):
contract = sp.contract(sp.TRecord(ticker=sp.TString),
params.oracleAddress,
entry_point="getDataFromOrO").open_some()
requestRecord = sp.record(ticker=params.ticker)
sp.transfer(requestRecord, sp.mutez(5000), contract)
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 TezToToken(self,
recipient: sp.TAddress,
tezIn: sp.TNat,
minTokensOut: sp.TNat):
this = self.data.address
sp.verify(tezIn > sp.mutez(0), message="Wrong tezIn")
sp.verify(minTokensOut > 0, message="Wrong minTokensOut")
fee = sp.fst(sp.ediv(tezIn, self.data.feeRate).open_some()) # TODO: ????
newTezPool = sp.local("newTezPool", self.data.tezPool).value + tezIn
tempTezPool = abs(newTezPool - fee)
newTokenPool = sp.fst(sp.ediv(sp.local(
"newTokenPool", self.data.invariant).value, tempTezPool).open_some())
tokensOut = abs(
sp.local("tokensOut", self.data.tokenPool).value - newTokenPool)
sp.verify(tokensOut >= minTokensOut, message="Wrong minTokensOut")
sp.verify(tokensOut <= self.data.tokenPool, message="Wrong tokenPool")
self.data.tezPool = newTezPool
self.data.tokenPool = newTokenPool
self.data.invariant = sp.split_tokens(newTezPool, newTokenPool, sp.nat(1))
token_contract = sp.contract(
sp.TRecord(account_from=sp.TAddress,
destination=sp.TAddress,
value=sp.TNat),
address=self.data.tokenAddress,
entry_point="Transfer"
).open_some()
sp.transfer(sp.record(account_from=this,
destination=recipient,
value=tokensOut),
sp.mutez(0),
token_contract)
def InitializeExchange(self, params):
token_amount = sp.as_nat(params.token_amount)
candidate = params.candidate
sp.verify(self.data.invariant == sp.mutez(0), message="Wrong invariant")
sp.verify(self.data.totalShares == 0, message="Wrong totalShares")
sp.verify(((sp.amount > sp.mutez(1)) & (
sp.amount < sp.tez(500000000))), message="Wrong amount")
sp.verify(token_amount > sp.nat(10), message="Wrong tokenAmount")
self.data.tokenPool = token_amount
self.data.tezPool = sp.amount
self.data.invariant = sp.split_tokens(self.data.tezPool, self.data.tokenPool, sp.nat(1))
self.data.shares[sp.sender] = sp.nat(1000)
self.data.totalShares = sp.nat(1000)
token_contract = sp.contract(
sp.TRecord(account_from=sp.TAddress,
destination=sp.TAddress,
value=sp.TNat),
address=self.data.tokenAddress,
entry_point="Transfer"
).open_some()
sp.transfer(sp.record(account_from=sp.sender,
destination=self.data.address,
value=token_amount),
sp.mutez(0),
token_contract)
self.data.candidates[sp.sender] = candidate
self.data.votes[candidate] = sp.as_nat(1000)
self.data.delegated = candidate
sp.set_delegate(sp.some(candidate))
def createVickreyAuctionInstance(self, asset_id, asset_name):
sp.verify(sp.sender == self.data.master_auction_contract)
contract_address = sp.some(sp.create_contract(
storage = sp.record(owner = sp.source,
master_auction_contract = sp.to_address(sp.self),
asset_id = asset_id,
# deposit will get seized if participant tries to cheat
deposit = 0,
sealed_bids = sp.map(tkey = sp.TAddress, tvalue = sp.TBytes),
# TODO: maintain revealed_participants list and only refund those
# possibly split the money b/w highest bidder and owner
# enforcing all participants to reveal their bids
# Then there'll be no need to maintain revealed_count & first_revealed
revealed_count = 0,
highest_bid = sp.mutez(0),
second_highest_bid = sp.mutez(0),
highest_bidder = sp.sender,
second_highest_bidder = sp.sender,
started = sp.bool(False),
first_revealed = sp.bool(False),
ended = sp.bool(False),
start_time = sp.now,
round_time = 0),
contract = self.vickrey))
# registerInstance
c = sp.contract(sp.TRecord(asset_id = sp.TNat, contract_address = sp.TAddress), self.data.master_auction_contract, entry_point = "registerInstance").open_some()
sp.transfer(sp.record(asset_id = asset_id, contract_address = contract_address.open_some()), sp.mutez(0), c)
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 transferHosp(self, params):
c = sp.contract(sp.TIntOrNat, address=params.address, entry_point="processRequest").open_some()
sp.transfer(arg=params.amtVaccine, amount=sp.tez(0), destination=c)
self.data.vaccineCount -= params.amtVaccine
sp.if params.address==self.data.hosp:
self.data.hosp=sp.address("KT1RcyuZeu6RcoeWDAUSVgUkrReWE2JrNMZh")
self.data.hospReqQ = 0
def endAuction(self, asset_id, owner):
self.data.ended = sp.bool(True)
# destroyInstance
c = sp.contract(sp.TRecord(asset_id=sp.TNat, owner=sp.TAddress),
self.data.master_auction_contract,
entry_point="destroyInstance").open_some()
sp.transfer(sp.record(asset_id=asset_id, owner=owner), sp.mutez(0), c)
def transferVaccine(self, params):
self.data.address = params.address
c = sp.contract(sp.TInt, address=self.data.address, entry_point="incCount").open_some()
sp.transfer(arg=params.reqVaccine, amount=sp.tez(0), destination=c)
self.data.vaccineAvailable -= params.reqVaccine
sp.if params.address==self.data.address:
self.data.address=sp.address("KT1RQBkagyLEHHx292djmg2MZ4CDpS5NYQeW")
self.data.req = 0
def getRequestFromClient(self,params):
sp.if self.data.apidata.contains(params.convkey):
sp.if sp.amount==sp.mutez(2000):
value = self.data.apidata[params.convkey]
comments = "Success"
c = sp.contract(sp.TRecord(value = sp.TInt, comments = sp.TString),sp.sender,entry_point="receiveDataFromOrO").open_some()
mydata = sp.record(value = value,comments = comments)
sp.transfer(mydata,sp.mutez(0),c)
def refund(self, _hashedSecret):
self.isRefundable(_hashedSecret)
c = sp.contract(sp.TRecord(from_=sp.TAddress, to_=sp.TAddress,
value=sp.TNat).layout(("from_ as from", ("to_ as to", "value"))), self.data.fa12, entry_point="transfer").open_some()
transferData = sp.record(
from_=sp.self_address, to_=self.data.swaps[_hashedSecret].initiator, value=self.data.swaps[_hashedSecret].value)
sp.transfer(transferData, sp.mutez(0), c)
del self.data.swaps[_hashedSecret]
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 LiquidateToken(self,params):
sp.set_type(params, sp.TRecord(address = sp.TAddress))
data = sp.record(price=self.data.USDPrice,address = params.address)
contract = sp.contract(sp.TRecord( price = sp.TNat, address = sp.TAddress),sp.sender,entry_point = "OracleLiquidate").open_some()
sp.transfer(data,sp.mutez(0),contract)
def key_request(self, params):
# you need to specify:
# a key
# a contract for a callback
# an entrypoint for the callback
c = sp.contract(sp.TNat, sp.sender,
entry_point="return_value").open_some()
sp.transfer(self.data.prices[params], sp.mutez(0), c)
def redeem(self, _hashedSecret, _secret):
self.checkState(_hashedSecret, State.Initiated)
self.isRedeemable(_hashedSecret, _secret)
c = sp.contract(sp.TRecord(from_=sp.TAddress, to_=sp.TAddress,
value=sp.TNat).layout(("from_ as from", ("to_ as to", "value"))), self.data.fa12, entry_point="transfer").open_some()
transferData = sp.record(
from_=sp.self_address, to_=self.data.swaps[_hashedSecret].participant, value=self.data.swaps[_hashedSecret].value)
sp.transfer(transferData, sp.mutez(0), c)
del self.data.swaps[_hashedSecret]
def addMembers(self,params):
sp.verify(sp.sender == self.data.admin)
sp.verify(self.data.membercount <= totalmembers)
memberaddress = self.data.addmemberdata[params.id].address
fa = sp.contract(sp.TRecord(address = sp.TAddress, value = sp.TNat),
self.data.tokencontract, entry_point = "mint").open_some()
sp.transfer(sp.record(address = memberaddress, value = 100), sp.tez(0), fa)
self.data.membermap[params.id] = True
self.data.membercount+=1
def MintToken(self,params):
sp.set_type(params, sp.TRecord(loan = sp.TNat))
data = sp.record(price=self.data.USDPrice,loan = params.loan)
contract = sp.contract(sp.TRecord( price = sp.TNat, loan = sp.TNat),sp.sender,entry_point = "OracleMint").open_some()
sp.transfer(data,sp.mutez(0),contract)
def transfer_to_customer(self, params):
customer_contract = sp.contract(sp.TIntOrNat, address = params.address, entry_point="process_request").open_some()
sp.transfer(arg = params.customer_request, amount=sp.tez(0), destination=customer_contract)
self.data.crops_available -= params.customer_request
self.data.income+=params.customer_request*self.data.customer_rate
sp.if params.address == self.data.customer:
self.data.customer = sp.address("KT1KS99kZk5WGagQXFSdN7tjgKkAKj1kAr9C")
self.data.customer_requirement = 0
self.data.customer_rate=0
def CollateralWithdraw(self,params):
sp.set_type(params, sp.TRecord(amount = sp.TNat))
data = sp.record(price=self.data.USDPrice,amount = params.amount)
contract = sp.contract(sp.TRecord( price = sp.TNat, amount = sp.TNat),sp.sender,entry_point = "OracleWithdrawCollateral").open_some()
sp.transfer(data,sp.mutez(0),contract)
def test():
scenario=sp.test_scenario()
scenario.h1("Calls back correctly when a valid asset is provided")
scenario.h2("GIVEN a Normalizer contract")
assetCode = "XTZ-USD"
contract=NormalizerContract(assetCodes=[assetCode])
scenario += contract
scenario.h2("AND a contract to call back to")
dummyContract = DummyContract()
scenario += dummyContract
scenario.h2("AND a single data point")
start1=sp.timestamp(1595104530)
high1=1
low1=2
close1=3
volume1=4
assetCode = "XTZ-USD"
scenario += contract.update(
makeMap(
assetCode=assetCode,
start=start1,
end=sp.timestamp(1595104531),
open=3059701,
high=high1,
low=low1,
close=close1,
volume=volume1
)
).run(sender=defaultOracleContractAddress)
scenario.h2("WHEN a request is made")
contractHandle = sp.contract(
sp.TPair(sp.TString, sp.TPair(sp.TTimestamp, sp.TNat)),
dummyContract.address,
entry_point = "callback"
).open_some()
param = (assetCode, contractHandle)
scenario.h2("THEN it succeeds.")
scenario += contract.get(param)
scenario.h2("AND the dummy contract captured the expected values")
scenario.verify(sp.fst(dummyContract.data.capturedCallbackValue) == assetCode)
scenario.verify(sp.fst(sp.snd(dummyContract.data.capturedCallbackValue)) == start1)
expectedPartialVWAP = Harbinger.computeVWAP(
high=high1,
low=low1,
close=close1,
volume=volume1
)
expectedPrice = expectedPartialVWAP // volume1
scenario.verify(sp.snd(sp.snd(dummyContract.data.capturedCallbackValue)) == expectedPrice)
def mint(self, params):
sp.verify(params.value>0)
tezValue=sp.tez(sp.as_nat(params.value))
sp.verify(sp.amount == tezValue)
c = sp.contract(sp.TRecord(address = sp.TAddress, amount = sp.TInt), self.data.OrO, entry_point = "getDataMint").open_some()
mydata = sp.record(address = sp.sender,amount=params.value)
sp.transfer(mydata, sp.mutez(10), c)
def initiateWait(self, _amount, _hashedSecret, _refundTimestamp, initiator_eth_addr):
self.contractIsActive()
self.isInitiable(_hashedSecret, _refundTimestamp)
c = sp.contract(sp.TRecord(from_=sp.TAddress, to_=sp.TAddress,
value=sp.TNat).layout(("from_ as from", ("to_ as to", "value"))), self.data.fa12, entry_point="transfer").open_some()
transferData = sp.record(
from_=sp.sender, to_=sp.self_address, value=_amount)
sp.transfer(transferData, sp.mutez(0), c)
self.data.swaps[_hashedSecret] = sp.record(hashedSecret=_hashedSecret, initiator_eth_addr=initiator_eth_addr, initiator=sp.sender,
participant=sp.sender, refundTimestamp=_refundTimestamp, value=_amount, state=State.Waiting)
def TransferToken(self,params):
sp.set_type(params, sp.TRecord(amount = sp.TNat))
sp.verify(sp.sender == self.data.owner)
sp.verify(self.data.Closed)
c = sp.contract(sp.TRecord(from_ = sp.TAddress, to_ = sp.TAddress , value = sp.TNat), self.data.stablecoin, entry_point = "transfer").open_some()
mydata = sp.record(from_ = sp.self_address,to_ = self.data.owner , value = params.amount)
sp.transfer(mydata, sp.mutez(0), c)
def TokenToExchangeLookup(self, params):
tokenOutAddress = params.tokenOutAddress
recepient = params.recepient
minTokensOut = params.minTokensOut
exchange = sp.contract(
sp.TRecord(recipient=sp.TAddress, minTokensOut=sp.TNat),
address=self.data.tokenToExchange[tokenOutAddress],
entry_point="TokenToTokenIn").open_some()
sp.transfer(sp.record(recipient=recepient, minTokensOut=minTokensOut),
sp.amount, exchange)
def breakGlass(self, newGovernor):
sp.set_type(newGovernor, sp.TAddress)
# Can only be called by the multisig.
sp.verify(sp.sender == self.data.multisigAddress, "NOT_MSIG")
targetContractHandle = sp.contract(
sp.TAddress, self.data.targetAddress,
'updateGovernorAddress').open_some()
sp.transfer(newGovernor, sp.mutez(0), targetContractHandle)
def placeBet(self,params):
sp.verify(self.data.betData.contains(params.betType), message="incorrect bet type")
sp.verify_equal(sp.amount,sp.mutez(self.data.betSize[params.betType]),message="incorrect amount sent to the entry point")
# multiplied seed by 10000 to retain last 6 digits of timestamp
uuid = self.data.uuid
self.data.uuid = self.data.uuid+1
self.data.tempData[uuid] = sp.record(seed=params.seed,sender=sp.sender,betType=params.betType)
entryAddress = sp.to_address(sp.self_entry_point(entry_point='placeBetFromOro'))
contract = sp.contract(sp.TRecord(uuid=sp.TNat,entryAddress=sp.TAddress),self.data.oracleAddress,entry_point="getDataFromOro").open_some()
sp.transfer(sp.record(uuid=uuid,entryAddress=entryAddress),sp.mutez(5000),contract)
