def get_type(self):
operator_transfer_policy = sp.TVariant(
no_transfer=sp.TUnit,
owner_transfer=sp.TUnit,
owner_or_operator_transfer=sp.TUnit)
if self.config.force_layouts:
operator_transfer_policy = operator_transfer_policy.layout(
("no_transfer",
("owner_transfer",
"owner_or_operator_transfer")))
owner_transfer_policy = sp.TVariant(
owner_no_hook=sp.TUnit,
optional_owner_hook=sp.TUnit,
required_owner_hook=sp.TUnit)
if self.config.force_layouts:
owner_transfer_policy = owner_transfer_policy.layout(
("owner_no_hook",
("optional_owner_hook",
"required_owner_hook")))
custom_permission_policy = sp.TRecord(
tag=sp.TString,
config_api=sp.TOption(sp.TAddress))
main = sp.TRecord(
operator=operator_transfer_policy,
receiver=owner_transfer_policy,
sender=owner_transfer_policy,
custom=sp.TOption(custom_permission_policy))
if self.config.force_layouts:
main = main.layout(("operator",
("receiver",
("sender", "custom"))))
return main
def __init__(self, admin):
with open('metadata/metadata.json', 'r') as f:
#loads then dumps to confirm correctly formatted json
metadata = json.dumps(json.load(f))
self.init(
paused=False,
balances=sp.big_map(tvalue=sp.TRecord(
approvals=sp.TMap(sp.TAddress, sp.TNat), balance=sp.TNat)),
administrator=admin,
totalSupply=0,
permits=sp.big_map(tkey=sp.TPair(sp.TAddress, sp.TBytes),
tvalue=sp.TTimestamp),
user_expiries=sp.big_map(tkey=sp.TAddress,
tvalue=sp.TOption(sp.TNat)),
permit_expiries=sp.big_map(tkey=sp.TPair(
sp.TAddress, sp.TBytes),
tvalue=sp.TOption(sp.TNat)),
counter=0,
default_expiry=50000,
max_expiry=2628000,
metadata=sp.big_map(
l={
"": sp.bytes_of_string("tezos-storage:md-json"),
"md-json": sp.bytes_of_string(metadata)
}))
def init_permit_data():
return sp.record(permits = sp.map(tkey=sp.TPair(sp.TAddress, sp.TBytes), tvalue=sp.TTimestamp),
user_expiries = sp.map(tkey=sp.TAddress, tvalue=sp.TOption(sp.TNat)),
permit_expiries = sp.map(tkey=sp.TPair(sp.TAddress, sp.TBytes), tvalue=sp.TOption(sp.TNat)),
counter = 0,
default_expiry = 50000,
max_expiry = 2628000)
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 vest(self, params):
sp.set_type(
params,
sp.TList(
sp.TRecord(
schedule_name = sp.TString,
beneficiery = sp.TAddress,
start = sp.TTimestamp,
end = sp.TTimestamp,
cliff = sp.TTimestamp,
vesting_amount = sp.TNat,
token_address = sp.TAddress,
token_id = sp.TOption(sp.TNat),
metadata=sp.TOption(sp.TMap(sp.TString, sp.TBytes))
)
)
)
sp.for schedule in params:
self._vest(schedule)
self._mint(
sp.record(
to_ = sp.self_address,
amount = schedule.vesting_amount,
token_id = schedule.token_id,
token_address = schedule.token_address,
metadata = schedule.metadata
)
)
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 get_type():
self_transfer_policy = sp.TVariant(
Self_transfer_permitted = sp.TUnit,
Self_transfer_denied = sp.TUnit)
operator_transfer_policy = sp.TVariant(
Operator_transfer_permitted = sp.TUnit,
Operator_transfer_denied = sp.TUnit)
owner_transfer_policy = sp.TVariant(
Owner_no_op = sp.TUnit,
Optional_owner_hook = sp.TUnit,
Required_owner_hook = sp.TUnit)
custom_permission_policy = sp.TRecord(
tag = sp.TString,
config_api = sp.TOption(sp.TAddress))
return sp.TRecord(
self_ = self_transfer_policy,
operator = operator_transfer_policy,
receiver = owner_transfer_policy,
sender = owner_transfer_policy,
custom = sp.TOption(custom_permission_policy))
def _vest(self, params):
sp.set_type(params,
sp.TRecord(
schedule_name = sp.TString,
beneficiery = sp.TAddress,
start = sp.TTimestamp,
end = sp.TTimestamp,
cliff = sp.TTimestamp,
vesting_amount = sp.TNat,
token_address = sp.TAddress,
token_id = sp.TOption(sp.TNat),
metadata=sp.TOption(sp.TMap(sp.TString, sp.TBytes))
)
)
# if you send the same schedule_name
# it will add to the vesting amount
schedule_name = params.schedule_name
sp.verify(params.start < params.cliff)
sp.verify(params.start < params.end)
sp.verify(params.cliff < params.end)
beneficiery = params.beneficiery
schedule = sp.record(
revoked = False,
revokedAt = sp.none,
revokedBy = sp.none,
start = params.start,
end = params.end,
cliff = params.cliff,
claimed_amount = sp.as_nat(0),
token_id = params.token_id,
token_address = params.token_address,
vesting_amount = params.vesting_amount,
)
sp.if ~self.data.schedules.contains(beneficiery):
self.data.schedules[beneficiery] = {}
self.data.schedules[beneficiery][schedule_name] = schedule
def __init__(self):
self.init(
schedules = sp.map(
tkey= sp.TAddress,
tvalue= sp.TMap(
sp.TString,
sp.TRecord(
revoked = sp.TBool,
revokedAt = sp.TOption(sp.TTimestamp),
revokedBy = sp.TOption(sp.TAddress),
start = sp.TTimestamp,
end = sp.TTimestamp,
cliff = sp.TTimestamp,
vesting_amount = sp.TNat,
claimed_amount = sp.TNat,
token_address = sp.TAddress,
token_id = sp.TOption(sp.TNat)
)
)
)
)
def __init__(self):
self.init_type(sp.TRecord(
admin = sp.TPair(sp.TAddress, sp.TAddress),
infoIPFS = sp.TString,
uuid = sp.TInt,
endTime = sp.TTimestamp,
result = sp.TOption(sp.TInt),
orders = Types.orderType,
buyLongOrders = Types.buyAndSellType,
buyShortOrders = Types.buyAndSellType,
sellLongOrders = Types.buyAndSellType,
sellShortOrders = Types.buyAndSellType,
sharesLong = Types.sharesType,
sharesShort = Types.sharesType
))
def __init__(self, admin):
self.add_flag("edo")
self.init(owner=admin,
current_price=0,
reserve_price=0,
in_progress=sp.bool(False),
start_time=sp.timestamp(0),
round_time=0,
ticket=sp.none)
self.init_type(t=sp.TRecord(owner=sp.TAddress,
current_price=sp.TNat,
reserve_price=sp.TNat,
in_progress=sp.TBool,
start_time=sp.TTimestamp,
round_time=sp.TInt,
ticket=sp.TOption(sp.TTicket(sp.TNat))))
def mint(self, token_id, royalty, metadata):
sp.set_type(token_id, sp.TNat)
sp.set_type(royalty, sp.TOption(Royalty.get_type()))
sp.set_type(metadata, sp.TBytes)
sp.verify(sp.sender == self.data.minter, message = FA2ErrorMessage.ONLY_MINTER_CAN_MINT)
sp.verify(~self.data.total_supply.contains(token_id), message = FA2ErrorMessage.TOKEN_ALREADY_EXISTS)
minter_ledger_key = LedgerKey.make(self.data.minter, token_id)
self.data.total_supply[token_id] = 1
self.data.ledger[minter_ledger_key] = 1
self.data.token_metadata[token_id] = sp.record(token_id = token_id, token_info = {"" : metadata})
sp.if royalty.is_some():
self.data.token_royalties[token_id] = sp.unit
register_token = sp.contract(sp.TRecord(token_id=sp.TNat, royalty=Royalty.get_type()), self.data.initial_auction_house_address, entry_point = "register_token").open_some()
sp.transfer(sp.record(token_id = token_id, royalty = royalty.open_some()), sp.tez(0), register_token)
def setExpiry(self, params):
sp.set_type(params, sp.TRecord(address=sp.TAddress, seconds=sp.TNat, permit=sp.TOption(
sp.TBytes))).layout(("address", ("seconds", "permit")))
sp.verify(~self.data.paused)
sp.verify(params.seconds <= self.data.max_expiry, "MAX_SECONDS_EXCEEDED")
sp.verify_equal(params.address, sp.sender, message="NOT_AUTHORIZED")
sp.if params.permit.is_some():
some_permit = params.permit.open_some()
sp.verify(self.data.permits.contains(
sp.pair(params.address, some_permit)), "PERMIT_NONEXISTENT")
permit_submission_timestamp = self.data.permits[sp.pair(
params.address, some_permit)]
sp.if self.data.permit_expiries.contains(sp.pair(params.address, some_permit)) & self.data.permit_expiries[sp.pair(params.address, some_permit)].is_some():
permit_expiry = self.data.permit_expiries[sp.pair(
params.address, some_permit)].open_some()
sp.verify(sp.as_nat(sp.now - permit_submission_timestamp)
< permit_expiry, "PERMIT_REVOKED")
def revoke(self, param):
# Recreate the message which should have been signed.
message = sp.set_type_expr(sp.none, sp.TOption(sp.TKey))
bytes = sp.pack(message)
# Verify that the message is signed correctly.
publicKey = self.data.publicKey.open_some()
sp.verify(sp.check_signature(publicKey, param, bytes))
# Revoke the Oracle's public Key.
self.data.publicKey = sp.none
# Remove all entries in the Oracle's map.
self.data.oracleData = sp.big_map(
l={},
tkey=sp.TString,
tvalue=Harbinger.OracleDataType
)
def setExpiry(self, params):
sp.set_type(params, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TOption(
sp.TBytes))))
address = sp.fst(params)
new_expiry = sp.fst(sp.snd(params))
possible_bytes = sp.snd(sp.snd(params))
sp.verify(new_expiry <= self.data.permit_data.max_expiry, self.error_message.expiry_exceeds_max())
sp.verify_equal(address, sp.sender, message=self.error_message.user_unauthorized())
sp.if possible_bytes.is_some():
some_permit = possible_bytes.open_some()
permit_key = sp.pair(address, some_permit)
sp.verify(self.data.permit_data.permits.contains(
permit_key), self.error_message.permit_nonexistent())
permit_submission_timestamp = self.data.permit_data.permits[permit_key]
effective_expiry = self.getEffectiveExpiry(permit_key)
sp.verify(sp.as_nat(sp.now - permit_submission_timestamp)
< effective_expiry, self.error_message.permit_revoked())
self.data.permit_data.permit_expiries[permit_key] = sp.some(new_expiry)
def __init__(self, t):
self.init(last = sp.none)
self.init_type(sp.TRecord(last = sp.TOption(t)))
