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 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 completeBet(self,params):
uuid = self.data.uuid
self.data.uuid = self.data.uuid+1
self.data.tempCompleteBetData[uuid] = sp.record(betId = params.betId,betType=params.betType)
entryAddress = sp.to_address(sp.self_entry_point(entry_point='completeBetFromOro'))
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)
def bobSignsState():
scenario.p("Bob signs the current state.")
result = sp.make_signature(bob.secret_key, sp.pack(
sp.record(id=c1.data.id, name="state", seq=cBob.data.seq, state=cBob.data.baseState)))
result = scenario.compute(result)
scenario.show(sp.record(seq=cBob.data.seq, sig=result))
return result
def createSealedBidAuctionInstance(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),
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.sealed_bid))
# 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 mutualClose(self, params):
sp.verify(self.data.status == OPEN)
# Check customer signature
sp.verify(sp.check_signature(self.data.custPk,
params.custSig,
sp.pack(sp.record(
chanID = self.data.chanID,
custAddr = self.data.custAddr,
merchAddr = self.data.merchAddr,
custBal = params.custBal,
merchBal = params.merchBal)
)
))
# Check merchant signature
sp.verify(sp.check_signature(self.data.merchPk,
params.merchSig,
sp.pack(sp.record(
chanID = self.data.chanID,
custAddr = self.data.custAddr,
merchAddr = self.data.merchAddr,
custBal = params.custBal,
merchBal = params.merchBal)
)
))
self.data.custBal = params.custBal
self.data.merchBal = params.merchBal
sp.send(self.data.custAddr, self.data.custBal)
sp.send(self.data.merchAddr, self.data.merchBal)
self.data.custBal = sp.tez(0)
self.data.merchBal = sp.tez(0)
self.data.status = CLOSED
def createDutchAuctionInstance(self, asset_id):
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=self.data.master_auction_contract,
asset_id=asset_id,
current_price=0,
reserve_price=0,
started=sp.bool(False),
ended=sp.bool(False),
start_time=sp.now,
round_time=0),
contract=self.dutch))
# 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 claimFor(self, beneficiery):
sp.verify(self.data.schedules.contains(beneficiery))
sp.for schedule_name in self.data.schedules[beneficiery].keys():
schedule = self.data.schedules[beneficiery][schedule_name]
vested_amount = self._vested(
sp.record(
beneficiery= beneficiery,
schedule_name= schedule_name
)
)
claim_amount = sp.local('claim_amount', sp.as_nat(0))
claim_amount.value = sp.as_nat(vested_amount - schedule.claimed_amount)
schedule.claimed_amount += claim_amount.value
self._transfer(
sp.record(
from_ = sp.self_address,
to_ = beneficiery,
amount = claim_amount.value,
token_id = schedule.token_id,
token_address = schedule.token_address
)
)
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 request_helper(self,
amount,
job_id,
parameters,
oracle,
waiting_request_id,
target,
timeout_minutes=5):
sp.verify(~waiting_request_id.is_some())
target = sp.set_type_expr(
target,
sp.TContract(
sp.TRecord(client_request_id=sp.TNat, result=value_type)))
waiting_request_id.set(sp.some(self.data.next_request_id))
token = sp.contract(sp.TRecord(oracle=sp.TAddress,
params=request_type),
self.data.token,
entry_point="proxy").open_some()
params = sp.record(amount=amount,
target=sp.to_address(target),
job_id=job_id,
parameters=parameters,
timeout=sp.now.add_minutes(timeout_minutes),
client_request_id=self.data.next_request_id)
sp.transfer(sp.record(oracle=oracle, params=params), sp.mutez(0),
token)
self.data.next_request_id += 1
def mint_OBJKT(self, params):
sp.verify((params.amount > 0) & ((params.royalties >= 0) & (params.royalties <= 250)) & (params.amount <= 10000))
c = sp.contract(
sp.TRecord(
address=sp.TAddress,
amount=sp.TNat,
token_id=sp.TNat,
token_info=sp.TMap(sp.TString, sp.TBytes)
),
self.data.objkt,
entry_point = "mint").open_some()
sp.transfer(
sp.record(
address=params.address,
amount=params.amount,
token_id=self.data.objkt_id,
token_info={ '' : params.metadata }
),
sp.mutez(0),
c)
self.data.royalties[self.data.objkt_id] = sp.record(issuer=sp.sender, royalties=params.royalties)
self.data.objkt_id += 1
def __init__(self):
self.init(
powerups=[
sp.record(power="time_freeze", duration=3),
sp.record(power="one_shot_kill", duration=4)
]
)
def test1():
scenario = sp.test_scenario()
scenario.h1("Candidates")
# Candidates
addr1 = sp.address("tz1LhS2WFCinpwUTdUb991ocL2D9Uk6FJGJK")
addr2 = sp.address("tz1a6SkBrxCywRHHsUKN3uQse7huiBNSGb5p")
addr3 = sp.address("tz3WXYtyDUNL91qfiCJtVUX746QpNv5i5ve5")
# Manager - can end the voting
addr4 = sp.address("tz1SwKQDtW8H7xLAS9ag4nxXbsQP5Pejwr7z")
# Voters
addr5 = sp.address("tz1SwKQDtW8H7xLAS9ag4nxXbsQP5Pejwr7z")
addr6 = sp.address("tz1YH2LE6p7Sj16vF6irfHX92QV45XAZYHnX")
contract = Ballot("Design", addr4, [(addr1, "George"), (addr2, "Tim"), (addr3, "Gina")], [addr5, addr6], 2)
contract.balance = sp.tez(9)
scenario += contract
# Votes succeed
scenario += contract.vote(votes = {addr1: 2}).run(valid = True,sender = addr5)
scenario += contract.vote(votes = {addr2: 1}).run(valid = True, sender = addr6)
# Not enough votes - vote fails
scenario += contract.vote(votes = {addr1: 1}).run(valid=False,sender = addr5)
# Assert addr1 has 2 votes, addr2 has 1 vote
scenario.verify(contract.data.ballot[addr1] == sp.record(candidateName = "George", numberOfVotes = 2))
scenario.verify(contract.data.ballot[addr2] == sp.record(candidateName = "Tim", numberOfVotes = 1))
# Ending contract
scenario += contract.end().run(valid = True, sender = addr4)
# Testing logic for ending contract
scenario.h1("End")
voterAccount = sp.test_account("Voter")
candidateAccount = sp.test_account("Canddidate")
managerAccount = sp.test_account("Manager")
contract = Ballot("End", managerAccount.address, [(candidateAccount.address, "Candidate")], [voterAccount.address], 10)
scenario += contract
# Vote for open voting succeeds
scenario += contract.vote(votes = {candidateAccount.address: 1}).run(valid = True, sender = voterAccount)
# Ending vote with voterAccount fails
scenario += contract.end().run(valid = False, sender = voterAccount)
# Ending vote with managerAccount succeeds
scenario += contract.end().run(valid = True, sender = managerAccount)
# Voting after ending fails
scenario += contract.vote(votes = {candidateAccount.address: 1}).run(valid = False, sender = voterAccount)
# Ending contract again fails
scenario += contract.end().run(valid = False, sender = managerAccount)
def test():
scenario = sp.test_scenario()
scenario.h1("Minimal")
c1 = EthClientOnTezos()
scenario += c1
scenario += c1.increment(sp.record(block = sp.record(hash = sp.string('sdhkf')) ))
scenario += c1
scenario += c1.add_block_header(sp.record(block = sp.record(parent_hash = sp.string('sdfsdf'), header_hash = sp.string('dfsdf'),header_number = 8)))
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)
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 test():
scenario = sp.test_scenario()
scenario.h1("PS sig verification")
pubkey = sp.record(g2=1, X=2, Y0=3, Y1=4, Y2=5, Y3=6, Y4=7)
c1 = PsSigContract(pubkey)
wallet = sp.record(m0=8, m1=9, m2=10, m3=11, m4=12)
signature = sp.record(s1=13, s2=14)
scenario += c1
scenario += c1.ps_sig_verify(wallet=wallet, signature=signature).run()
scenario.table_of_contents()
def Contract_Initialisation(self, price, start_date, dep_date, nuki, deposit, fair, owner, visitor, contract):
self.data.price = price
sp.verify(start_date != dep_date)
self.data.start_date = start_date
self.data.dep_date = dep_date
self.data.nuki = nuki
self.data.deposit = deposit
self.data.fair = fair
self.data.balances[owner] = sp.record(balance = sp.tez(100))
self.data.balances[contract] = sp.record(balance = sp.tez(0))
self.data.balances[visitor] = sp.record(balance = sp.tez(100))
def f_process_request(req):
user = self.ledger_key.make(req.owner, req.token_id)
sp.verify(self.data.token_metadata.contains(req.token_id), message = self.error_message.token_undefined())
sp.if self.data.ledger.contains(user):
balance = self.data.ledger[user].balance
sp.result(
sp.record(
request = sp.record(
owner = sp.set_type_expr(req.owner, sp.TAddress),
token_id = sp.set_type_expr(req.token_id, sp.TNat)),
balance = balance))
def contribute(self, params):
sp.verify(sp.now <= self.data.end_date)
tezValue=sp.tez(sp.as_nat(params.amount))
sp.verify(sp.amount == tezValue)
c = sp.contract(sp.TRecord(address = sp.TAddress, amount = sp.TInt), self.data.tokenContract, entry_point = "mint").open_some()
sp.if self.data.xtzContributionTotal < 50000 :
mydata = sp.record(address = sp.sender,amount=params.amount*1200)
sp.transfer(mydata, sp.amount, c)
mydata = sp.record(address = self.data.administrator,amount=params.amount*120)
sp.transfer(mydata, sp.mutez(0), c)
def addDAO(self,stre,mincontribution,mtoken,vstart,vend,disend,cont):
sp.set_type(mincontribution, sp.TMutez)
mincontribution=mincontribution
sp.verify(sp.now<disend)
sp.if self.data.addmemberdata.contains(sp.sender)==False:
self.data.DAO_id +=1
keyindex=self.data.DAO_id
sp.verify(sp.amount == mincontribution)
self.data.addDAOdata[keyindex] = sp.record(admin=sp.sender,strength=stre,min_contribution=mincontribution,serialno=keyindex,winproposalid=-1,winprojectid=-1,maxtoken=mtoken,proposedproposalid=-1,proposedprojectid=-1,disputevotecount=0,maxmember=1,disputestatus=0,rewardstatus=0,votestart=vstart,voteend=vend,disputeend=disend,currentcount=1,contri=cont)
self.data.addmemberdata[sp.sender]=sp.record(DAO=keyindex,contribution=sp.amount,tokenbalance=mtoken)
def test():
scenario = sp.test_scenario()
oracle = PlayerFantasyPointsOracle(
sp.address('tz1dJVWP5nAd2dfNQhpDQdGefQoED7aRy8qn'))
scenario += oracle
scenario += oracle.feedData(array=[sp.record(player_id=0, points=369, rank=1), sp.record(player_id=1, points=284, rank=2),
sp.record(player_id=2, points=260, rank=3)]).run(sender=sp.address('tz1beX9ZDev6SVVW9yJwNYA89362ZpWuDwou'))
scenario += oracle.getDataFromOrO().run(sender=sp.address("KT1-AAA"),
amount=sp.mutez(5000))
scenario += oracle.getDataFromOrO().run(sender=sp.address("KT1-BBB"),
amount=sp.mutez(4000))
def create_auction(self, create_auction_request):
sp.set_type_expr(create_auction_request, AuctionCreateRequest.get_type())
token_contract = sp.contract(BatchTransfer.get_type(), create_auction_request.token_address, entry_point = "transfer").open_some()
sp.verify(create_auction_request.token_amount > 0, message=AuctionErrorMessage.TOKEN_AMOUNT_TOO_LOW)
sp.verify(create_auction_request.end_timestamp >= sp.now.add_hours(MINIMAL_AUCTION_DURATION), message=AuctionErrorMessage.END_DATE_TOO_SOON)
sp.verify(create_auction_request.end_timestamp <= sp.now.add_hours(MAXIMAL_AUCTION_DURATION), message=AuctionErrorMessage.END_DATE_TOO_LATE)
sp.verify(create_auction_request.bid_amount >= MINIMAL_BID, message=AuctionErrorMessage.BID_AMOUNT_TOO_LOW)
sp.verify(~self.data.auctions.contains(create_auction_request.auction_id), message=AuctionErrorMessage.ID_ALREADY_IN_USE)
sp.transfer([BatchTransfer.item(sp.sender, [sp.record(to_=sp.self_address, token_id=create_auction_request.token_id, amount=create_auction_request.token_amount)])], sp.mutez(0), token_contract)
self.data.auctions[create_auction_request.auction_id] = sp.record(token_address=create_auction_request.token_address, token_id=create_auction_request.token_id, token_amount=create_auction_request.token_amount, end_timestamp=create_auction_request.end_timestamp, seller=sp.sender, bid_amount=create_auction_request.bid_amount, bidder=sp.sender)
def proxy(self, oracle, params):
self.transfer.f(self, [
sp.record(
from_=sp.sender,
txs=[sp.record(to_=oracle, token_id=0, amount=params.amount)])
])
oracle_contract = sp.contract(
sp.TRecord(client=sp.TAddress, params=request_type),
oracle,
entry_point="create_request").open_some()
sp.transfer(sp.record(client=sp.sender, params=params), sp.mutez(0),
oracle_contract)
def sendQuery(self, params):
handler = sp.contract(qType, self.data.oracle,
entry_point="makeQuery").open_some()
args = sp.record(
# id = params.id,
jurisdiction=params.jurisdiction,
companyNumber=params.companyNumber,
callback=sp.record(address=sp.to_address(sp.self),
entryPoint="receiveAnswer")
#sp.contract(rType, sp.to_address(sp.self), entry_point = "receiveAnswer").open_some()
)
sp.transfer(args, sp.tez(0), handler)
def balance_of(self, params):
sp.set_type(params, BalanceOf.entry_point_type())
res = sp.local("responses", [])
sp.set_type(res.value, BalanceOf.response_type())
sp.for req in params.requests:
user = LedgerKey.make(req.owner, req.token_id)
balance = self.data.ledger[user]
res.value.push(
sp.record(
request=sp.record(
owner=sp.set_type_expr(req.owner, sp.TAddress),
token_id=sp.set_type_expr(req.token_id, sp.TNat)),
balance=balance))
def cancel_request(self, client_request_id):
# We do not want to check active here (it would be bad for the client).
# sp.sender needs to be validated; this process is done through the use of the reverse_request_key.
reverse_request_key = sp.compute(sp.record(client = sp.sender, client_request_id = client_request_id))
request_id = sp.local('request_id', self.data.reverse_requests[reverse_request_key]).value
request = sp.local('request', self.data.requests[request_id]).value
sp.verify(request.timeout <= sp.now, message = "TTL not met")
token = sp.contract(self.token_contract.batch_transfer.get_type(), self.data.token, entry_point = "transfer").open_some(message = "Incompatible token interface")
sp.transfer([sp.record(from_ = sp.to_address(sp.self), txs = [sp.record(to_ = request.client, token_id = 0, amount = request.amount)])],
sp.tez(0),
token)
del self.data.requests[request_id]
del self.data.reverse_requests[reverse_request_key]
def test():
scenario = sp.test_scenario()
scenario.h1("Chainlink Oracles")
scenario.table_of_contents()
scenario.h2("Accounts")
admin = sp.test_account("Administrator")
bob = sp.address("tz1WdHqcAo7gjtFDPMgD6yN8pk1sq67MJRjH")
oracle1 = sp.test_account("Oracle1")
client1_admin = sp.test_account("Client1 admin")
client2_admin = sp.test_account("Client2 admin")
scenario.show([admin, oracle1, client1_admin, client2_admin])
scenario.h2("Link Token")
link_token = Link_token(FA2.FA2_config(single_asset = True), admin.address)
scenario += link_token
scenario += link_token.mint(address = admin.address,
amount = 200,
symbol = 'tzLINK',
token_id = 0).run(sender = admin)
scenario.h2("Token Faucet")
faucet = TokenFaucet(admin.address, link_token, link_token.address, 10)
scenario += faucet
scenario.h2("Oracle")
oracle = Oracle(oracle1.address, link_token)
scenario += oracle
scenario.h2("Client1")
client1 = Client(link_token.address, oracle.address, sp.bytes("0x0001"), client1_admin.address)
scenario += client1
scenario.h2("Client2")
client2 = Client(link_token.address, oracle.address, sp.bytes("0x0001"), client2_admin.address)
scenario += client2
scenario.h2("Tokens")
scenario += link_token.transfer([sp.record(from_ = admin.address, txs = [sp.record(to_ = faucet.address, token_id = 0, amount = 100)])]).run(sender = admin)
scenario += link_token.transfer([sp.record(from_ = admin.address, txs = [sp.record(to_ = oracle1.address, token_id = 0, amount = 1)])]).run(sender = admin)
scenario += faucet.request_tokens(sp.set([client1.address, client2.address]))
#scenario += link_token.transfer([sp.record(from_ = client1_admin.address, txs = [sp.record(to_ = client1.address, token_id = 0, amount = 10)])]).run(sender = client1_admin)
scenario.h2("Client1 sends a request that gets fulfilled")
scenario.h3("A request")
scenario += client1.request_fortune(payment = 1, timeout = 10).run(sender = bob)
def OpenVault(self,params):
self.data.contract = sp.create_contract(storage=sp.record(token=sp.nat(0),xtz=sp.nat(0),
owner = sp.sender, oracle = self.data.oracle , Closed = True,stablecoin = self.data.token,
Insurance = sp.now, securityDelegator = sp.sender
),
contract = self.Vault
)
c = sp.contract(sp.TRecord( address = sp.TAddress, owner = sp.TAddress), self.data.token, entry_point = "AddVault").open_some()
mydata = sp.record(address = self.data.contract , owner = sp.sender)
sp.transfer(mydata, sp.mutez(0), c)
def balance_of(self, params):
# paused may mean that balances are meaningless:
sp.verify( ~self.data.paused )
res = sp.local("responses", [])
sp.set_type(res.value, Balance_of.response_type())
sp.for req in params.requests:
user = Ledger_key.make(req.owner, req.token_id)
balance = self.data.ledger[user].balance
res.value.push(
sp.record(
request = sp.record(
owner = sp.set_type(req.owner, sp.TAddress),
token_id = sp.set_type(req.token_id, sp.TNat)),
balance = balance))
