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)