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)))