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 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 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 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 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 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 collect(self, params):
sp.verify(params.objkt_amount > 0)
self.fa2_transfer(self.data.ung, sp.sender, self.data.swaps[params.swap_id].issuer, 1, self.data.swaps[params.swap_id].ung_per_objkt * params.objkt_amount)
self.fa2_transfer(self.data.objkt, sp.to_address(sp.self), sp.sender, self.data.swaps[params.swap_id].objkt_id, params.objkt_amount)
self.data.swaps[params.swap_id].objkt_id = abs(self.data.swaps[params.swap_id].objkt_id - params.objkt_amount)
sp.if (self.data.swaps[params.swap_id].objkt_amount == 0):
del self.data.swaps[params.swap_id]
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 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 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 fulfill_request(self, request_id, result):
# Please note that the target (i.e., the requestor) could refuse to receive the data.
# We do not want to check active here since sp.sender == admin.
sp.verify(self.data.admin == sp.sender, message = "Privileged operation")
request = sp.local('request', self.data.requests[request_id]).value
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_ = self.data.admin, token_id = 0, amount = request.amount)])],
sp.tez(0),
token)
target = sp.contract(sp.TRecord(client_request_id = sp.TNat, result = value_type), request.target).open_some(message = "Incompatible client interface")
sp.transfer(sp.record(client_request_id = request.client_request_id, result = result), sp.mutez(0), target)
del self.data.requests[request_id]
reverse_request_key = sp.record(client = request.client, client_request_id = request.client_request_id)
del self.data.reverse_requests[reverse_request_key]
def createDutchAuctionInstance(self, asset_id, asset_name):
contract_address = sp.create_contract(
storage = sp.record(owner = sp.sender,
master_auction_contract = sp.to_address(sp.self),
asset_id = asset_id,
current_price = 0,
reserve_price = 0,
started = sp.bool(False),
ended = sp.bool(False),
start_time = sp.now,
wait_time = 0),
contract = self.dutch)
self.data.instances_map[asset_id] = sp.record(
asset_name = asset_name,
auction_type = "dutch",
owner = sp.sender,
contract_address = contract_address,
is_available = sp.bool(True))
def getAddressInfoFromRegistry(self, params):
# type of response
tkResponse = sp.TRecord(
name = sp.TString,
info = sp.TRecord(
name = sp.TString,
owner = sp.TAddress,
resolver = sp.TAddress,
registeredAt = sp.TTimestamp,
registrationPeriod = sp.TInt,
modified = sp.TBool))
# callback handle for the receiver entrypoint
kResponse = sp.contract(tkResponse, sp.to_address(sp.self), entry_point = "recvAddressInfo").open_some()
# type of request
tkRequest = sp.TRecord(addr = sp.TAddress, k = sp.TContract(tkResponse))
kRequest = sp.contract(tkRequest, self.data.registry, entry_point = "sendAddressInfo").open_some()
sp.transfer(sp.record(addr = params.addr, k = kResponse), sp.mutez(0), kRequest)
def createEnglishAuctionInstance(self, asset_id, asset_name):
contract_address = sp.some(sp.create_contract(
storage = sp.record(owner = sp.sender,
master_auction_contract = sp.to_address(sp.self),
asset_id = asset_id,
current_bid = sp.mutez(0),
min_increase = 0,
highest_bidder = sp.sender,
started = sp.bool(False),
ended = sp.bool(False),
start_time = sp.now,
wait_time = 0),
contract = self.english))
self.data.instances_map[asset_id] = sp.record(
asset_name = asset_name,
auction_type = "english",
owner = sp.sender,
contract_address = contract_address.open_some(),
is_available = sp.bool(True))
def permit(self, params):
sp.set_type(params, sp.TList(
sp.TPair(sp.TKey, sp.TPair(sp.TSignature, sp.TBytes))))
sp.for permit in params:
public_key = sp.fst(permit)
signature = sp.fst(sp.snd(permit))
params_hash = sp.snd(sp.snd(permit))
#unsigned = sp.blake2b(mi.operator("SELF; ADDRESS; CHAIN_ID; PAIR; PAIR; PACK", [sp.TPair(sp.TNat, sp.TBytes)], [sp.TBytes])(sp.pair(self.data.permit_data.counter, params_hash)))
unsigned = sp.pack(sp.pair(sp.pair(sp.chain_id, sp.self_address), sp.pair(
self.data.permit_data.counter, params_hash)))
pk_address = sp.to_address(
sp.implicit_account(sp.hash_key(public_key)))
permit_key = sp.pair(pk_address, params_hash)
permit_exists = self.data.permit_data.permits.contains(permit_key)
permit_submission_timestamp = self.data.permit_data.permits[permit_key]
effective_expiry = self.getEffectiveExpiry(permit_key)
sp.verify(~ (permit_exists & (sp.as_nat(sp.now - permit_submission_timestamp) < effective_expiry)),
sp.pair(self.error_message.duplicate_permit(), params_hash))
sp.verify(sp.check_signature(public_key, signature, unsigned), sp.pair(self.error_message.permit_missigned(), unsigned))
self.data.permit_data.permits[permit_key] = sp.now
self.data.permit_data.counter = self.data.permit_data.counter + 1
def buy_powerup(self, powerup):
# modify data_type to also hold another variable called cryptobot_address.
data_type = sp.TRecord(powerup=sp.TString, cryptobot_contract=sp.TContract(
sp.TRecord(power=sp.TString, duration=sp.TNat)))
market_contract = sp.contract(
data_type, self.data.market_address).open_some()
self.data.mutez_points -= sp.mutez(3000)
# define self_contract -
# 1. Accepts a record with two variables - power(string), duration(nat)
# 2. Points to the Cryptobot( use sp.to_address() )
# 3. Specifies receive_powerup entry point
self_contract = sp.contract(sp.TRecord(power=sp.TString, duration=sp.TNat), sp.to_address(
sp.self), "receive_powerup").open_some()
# modify data_to_be_sent to also hold cryptobot_contract which is assigned self_contract
data_to_be_sent = sp.record(
powerup=powerup, cryptobot_contract=self_contract)
sp.transfer(data_to_be_sent, sp.mutez(0), market_contract)
def sendQuery(self, params):
rtype = sp.TRecord(
currencyPair = sp.TString,
value = sp.TNat,
precision = sp.TNat,
timestamp = sp.TTimestamp,
source = sp.TString)
ptype = sp.TRecord(
currencyPair = sp.TString,
callback = sp.TContract(rtype)
)
getHandle = sp.contract(ptype, self.data.oracle, entry_point = "processDataRequest").open_some()
args = sp.record(
currencyPair = params.currencyPair,
callback = sp.contract(rtype,
sp.to_address(sp.self),
entry_point = "receiveData").open_some()
)
sp.transfer(args, sp.tez(1000), getHandle)
def __init__(self,
feeRate: sp.TNat,
tokenAddress: sp.TAddress,
factoryAddress: sp.TAddress,
delegated: sp.TKeyHash):
self.init(
feeRate=sp.nat(feeRate),
tezPool=sp.mutez(0),
tokenPool=sp.nat(0),
invariant=sp.mutez(0),
totalShares=sp.nat(0),
tokenAddress=tokenAddress,
factoryAddress=factoryAddress,
# sp.TAddress, sp.TNat
shares=sp.big_map(tkey=sp.TAddress, tvalue=sp.TNat),
# sp.TAddress, sp.TKeyHash
candidates=sp.big_map(tkey=sp.TAddress, tvalue=sp.TKeyHash),
# sp.TKeyHash, sp.TNat
votes=sp.big_map(tkey=sp.TKeyHash, tvalue=sp.TNat),
delegated=delegated,
address=tokenAddress
)
self.data.address = sp.to_address(sp.self)
def cancel_swap(self, params):
sp.verify( (self.data.swaps[params].issuer == sp.sender) )
self.fa2_transfer(self.data.objkt, sp.to_address(sp.self), sp.sender, self.data.swaps[params].objkt_id, self.data.swaps[params].objkt_amount)
del self.data.swaps[params]
def swap(self, params):
sp.verify((params.objkt_amount > 0))
self.fa2_transfer(self.data.objkt, sp.sender, sp.to_address(sp.self), params.objkt_id, params.objkt_amount)
self.data.swaps[self.data.swap_id] = sp.record(issuer=sp.sender, objkt_id=params.objkt_id, objkt_amount=params.objkt_amount, xtz_per_objkt=params.xtz_per_objkt)
self.data.swap_id += 1
class OBJKTSwap(sp.Contract):
def __init__(self, objkt, hdao, manager, metadata, curate):
self.fee = 0
self.amount = 0
self.royalties = 0
self.init(
swaps = sp.big_map(tkey=sp.TNat, tvalue=sp.TRecord(issuer=sp.TAddress, xtz_per_objkt=sp.TMutez, objkt_id=sp.TNat, objkt_amount=sp.TNat)),
royalties = sp.big_map(tkey=sp.TNat, tvalue=sp.TRecord(issuer=sp.TAddress, royalties=sp.TNat)),
swap_id = 0,
objkt_id = 152,
objkt = objkt,
hdao = hdao,
manager = manager,
metadata = metadata,
genesis = sp.timestamp(0),
curate = curate,
locked = False
)
@sp.entry_point
def genesis(self):
sp.verify((sp.sender == self.data.manager) & ~(self.data.locked))
self.data.genesis = (sp.now).add_days(45)
self.data.locked = True
@sp.entry_point
def update_manager(self, params):
sp.verify(sp.sender == self.data.manager)
self.data.manager = params
@sp.entry_point
def swap(self, params):
sp.verify((params.objkt_amount > 0))
self.fa2_transfer(self.data.objkt, sp.sender, sp.to_address(sp.self), params.objkt_id, params.objkt_amount)
self.data.swaps[self.data.swap_id] = sp.record(issuer=sp.sender, objkt_id=params.objkt_id, objkt_amount=params.objkt_amount, xtz_per_objkt=params.xtz_per_objkt)
self.data.swap_id += 1
@sp.entry_point
def cancel_swap(self, params):
sp.verify( (self.data.swaps[params].issuer == sp.sender) )
self.fa2_transfer(self.data.objkt, sp.to_address(sp.self), sp.sender, self.data.swaps[params].objkt_id, self.data.swaps[params].objkt_amount)
del self.data.swaps[params]
@sp.entry_point
def collect(self, params):
sp.verify( (params.objkt_amount > 0) & (sp.sender != self.data.swaps[params.swap_id].issuer) )
sp.if (self.data.swaps[params.swap_id].xtz_per_objkt != sp.tez(0)):
self.objkt_amount = sp.fst(sp.ediv(sp.amount, self.data.swaps[params.swap_id].xtz_per_objkt).open_some())
self.amount = self.objkt_amount * sp.fst(sp.ediv(self.data.swaps[params.swap_id].xtz_per_objkt, sp.mutez(1)).open_some())
sp.verify((params.objkt_amount == self.objkt_amount) & (sp.amount == sp.utils.nat_to_mutez(self.amount)) & (sp.amount > sp.tez(0)))
# calculate fees and royalties
self.fee = sp.fst(sp.ediv(sp.utils.nat_to_mutez(self.amount), sp.utils.nat_to_mutez(1)).open_some()) * (self.data.royalties[self.data.swaps[params.swap_id].objkt_id].royalties + 25) / 1000
self.royalties = self.data.royalties[self.data.swaps[params.swap_id].objkt_id].royalties * self.fee / (self.data.royalties[self.data.swaps[params.swap_id].objkt_id].royalties + 25)
# send royalties to NFT creator
sp.send(self.data.royalties[self.data.swaps[params.swap_id].objkt_id].issuer, sp.utils.nat_to_mutez(self.royalties))
# send management fees
sp.send(self.data.manager, sp.utils.nat_to_mutez(abs(self.fee - self.royalties)))
# send value to issuer
sp.send(self.data.swaps[params.swap_id].issuer, sp.amount - sp.utils.nat_to_mutez(self.fee))
# off on test scenarios
# sp.if (sp.now < self.data.genesis):
#self.mint_hDAO([sp.record(to_=sp.sender, amount=self.amount / 2), sp.record(to_=self.data.swaps[params.swap_id].issuer, amount=self.amount / 2), sp.record(to_=self.data.manager, amount=abs(self.fee - self.royalties))])
self.fa2_transfer(self.data.objkt, sp.to_address(sp.self), sp.sender, self.data.swaps[params.swap_id].objkt_id, params.objkt_amount)
self.data.swaps[params.swap_id].objkt_amount = abs(self.data.swaps[params.swap_id].objkt_amount - params.objkt_amount)
sp.if (self.data.swaps[params.swap_id].objkt_amount == 0):
del self.data.swaps[params.swap_id]
def token_metadata_registry(self, params):
sp.verify(~self.data.paused)
sp.set_type(params, sp.TContract(sp.TAddress))
sp.transfer(sp.to_address(sp.self), sp.mutez(0), params)
asset_id = sp.local('asset_id', params.asset_id)
asset_name = sp.local('asset_name', params.asset_name)
sp.if asset_id.value == 0:
asset_id.value = self.data.counter
self.data.counter = self.data.counter + 1
sp.else:
sp.verify((self.data.instances_map[asset_id.value].owner == sp.sender))
sp.verify((self.data.instances_map[asset_id.value].is_available), "cannot auction as the asset is unavailable")
asset_name.value = self.data.instances_map[asset_id.value].asset_name
self.data.instances_map[asset_id.value] = sp.record(
asset_name = asset_name.value,
auction_type = params.auction_type,
owner = sp.sender,
contract_address = sp.to_address(sp.self),
is_available = sp.bool(True))
sp.verify(((params.auction_type == "english") | (params.auction_type == "dutch") | (params.auction_type == "sealed bid")), "incorrect auction_type")
sp.if params.auction_type == "dutch":
d = sp.contract(sp.TNat, self.data.dutch_factory, entry_point = "createDutchAuctionInstance").open_some()
sp.transfer(asset_id.value, sp.mutez(0), d)
sp.if params.auction_type == "english":
e = sp.contract(sp.TNat, self.data.english_factory, entry_point = "createEnglishAuctionInstance").open_some()
sp.transfer(asset_id.value, sp.mutez(0), e)
sp.if params.auction_type == "sealed bid":
s = sp.contract(sp.TNat, self.data.sealed_bid_factory, entry_point = "createSealedBidAuctionInstance").open_some()
sp.transfer(asset_id.value, sp.mutez(0), s)
sp.if params.auction_type == "vickrey":
v = sp.contract(sp.TNat, self.data.vickrey_factory, entry_point = "createVickreyAuctionInstance").open_some()
sp.transfer(asset_id.value, sp.mutez(0), v)
def transfer(self, params):
arg = sp.TRecord(fro = sp.TAddress, to = sp.TAddress, value = sp.TNat)
arg_inst = sp.record(fro = sp.to_address(sp.self), to = params, value = self.data.tk_amount)
c = sp.contract(arg, self.data.fa12, entry_point="transfer").open_some()
sp.transfer(arg_inst, sp.mutez(0), c)
def leave_hDAO(self, params):
#sp.verify( self.data.auth.get(sp.sender, False ) )
self.fa2_transfer(self.data.ung, sp.sender, sp.to_address(sp.self), 1, params)
sp.send(sp.sender, sp.mutez(params))
self.data.balance -= sp.mutez(params)
