def get_type(): if support_operator: return sp.TRecord( balance = sp.TNat, operators = sp.TSet(sp.TAddress)) else: return sp.TRecord(balance = sp.TNat)
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 __init__(self, _name, _symbol, _admin): self.init( name = _name, symbol = _symbol, admin = _admin, tokensMinted = sp.set( t= sp.TString), tokenHolderToID = sp.big_map(tkey = sp.TAddress, tvalue = sp.TSet(sp.TString)), ownerToBalance = sp.big_map(tkey = sp.TAddress, tvalue = sp.TInt), tokenIdToOwner = sp.big_map(tkey = sp.TString, tvalue = sp.TAddress), tokenApprovals = sp.big_map(tkey = sp.TString, tvalue = sp.TAddress), )
def get_type(): return sp.TRecord( balance=sp.TNat, operators=sp.TSet( sp.TAddress ), approvals=sp.TMap( sp.TAddress, sp.TNat, ), )
def make_roles(administrators=sp.set([], t=sp.TAddress), validators=sp.set([], t=sp.TAddress), controllers=sp.set([], t=sp.TAddress)): return sp.map( { ADMIN_ROLE: make_role(ADMIN_ROLE, administrators), ALLOWLIST_ADMIN_ROLE: make_role(ADMIN_ROLE, controllers), BLOCKLIST_ADMIN_ROLE: make_role(ADMIN_ROLE) }, tkey=sp.TNat, tvalue=sp.TRecord( role_admin=sp.TNat, members=sp.TSet(t=sp.TAddress) ) )
def __init__(self, initOwners): # Owners are locked at initialization in this iteration # Future iterations could have dynamic owners self.init( owners=sp.set(initOwners), numOwners=sp.len(initOwners), locked=False, closed=False, lock_votes=sp.set([], sp.TAddress), close_votes=sp.set([], sp.TAddress), total_contributed=sp.mutez(0), total_liquidated=sp.mutez(0), liquidated_ledger=sp.big_map({}, sp.TAddress, sp.TMutez), equity=sp.big_map({}, sp.TAddress, sp.TMutez), buy_proposals=sp.big_map({}, sp.TNat, sp.TRecord(votes=sp.TSet(sp.TAddress), passed=sp.TBool)), swap_proposals=sp.big_map({}), cancel_swap_proposals=sp.big_map({}, sp.TNat, sp.TRecord(votes=sp.TSet(sp.TAddress), passed=sp.TBool)), swap_proposal_id=0, # Used for collect/swap/cancel_swap hen_address = sp.address("KT1HbQepzV1nVGg8QVznG7z4RcHseD5kwqBn"), # Used for update_operators hen_nft_address = sp.address("KT1RJ6PbjHpwc3M5rw5s2Nbmefwbuwbdxton") )
def __init__(self, manager, registrars): self.init( manager=manager, registrars=registrars, lands=sp.big_map(tkey=sp.TString, tvalue=sp.TRecord( A=sp.TPair(sp.TInt, sp.TInt), B=sp.TPair(sp.TInt, sp.TInt), C=sp.TPair(sp.TInt, sp.TInt), D=sp.TPair(sp.TInt, sp.TInt) )), land_owners=sp.map(tkey=sp.TAddress, tvalue=sp.TSet(sp.TString)) )
def make_roles(administrators, validators, controllers, burners, minters): return sp.map( { ADMIN_ROLE: make_role(ADMIN_ROLE, administrators), CONTROLLER_ROLE: make_role(ADMIN_ROLE, controllers), MINTER_ROLE: make_role(ADMIN_ROLE, minters), BURNER_ROLE: make_role(ADMIN_ROLE, burners), PAUSER_ROLE: make_role(ADMIN_ROLE), VALIDATOR_ROLE: make_role(ADMIN_ROLE, validators) }, tkey=sp.TNat, tvalue=sp.TRecord( role_admin=sp.TNat, members=sp.TSet(t=sp.TAddress) ) )
def __init__(self, config, admin): self.config = config self.error_message = Error_message(self.config) self.operator_set = Operator_set(self.config) self.operator_param = Operator_param(self.config) self.token_id_set = Token_id_set(self.config) self.ledger_key = Ledger_key(self.config) self.token_meta_data = Token_meta_data(self.config) self.permissions_descriptor_ = Permissions_descriptor(self.config) self.batch_transfer = Batch_transfer(self.config) self.player_meta_data = Player_meta_data(self.config) self.player_id_set = Player_id_set(self.config) if self.config.add_mutez_transfer: self.transfer_mutez = sp.entry_point(mutez_transfer) if self.config.add_permissions_descriptor: def permissions_descriptor(self, params): sp.set_type(params, sp.TContract( self.permissions_descriptor_.get_type())) v = self.permissions_descriptor_.make() sp.transfer(v, sp.mutez(0), params) self.permissions_descriptor = sp.entry_point( permissions_descriptor) if config.lazy_entry_points: self.add_flag("lazy_entry_points") if config.lazy_entry_points_multiple: self.add_flag("lazy_entry_points_multiple") self.exception_optimization_level = "DefaultLine" self.init( paused=False, ledger=self.config.my_map(tvalue=Ledger_value.get_type()), tokens=self.config.my_map(tvalue=self.token_meta_data.get_type()), operators=self.operator_set.make(), administrator=admin, all_tokens=self.token_id_set.empty(), players=self.config.my_map( tkey=sp.TNat, tvalue=self.player_meta_data.get_type()), tokens_on_sale=sp.big_map(tkey=sp.TNat, tvalue=sp.TRecord( owner=sp.TAddress, price=sp.TMutez)), selected_tokens=sp.map( tkey=sp.TAddress, tvalue=sp.TRecord(tokens=sp.TSet(sp.TNat))), matches=sp.map(tkey=sp.TNat, tvalue=sp.TRecord( teamA=sp.TString, teamB=sp.TString, active=sp.TBool, finished=sp.TBool, date=sp.TString, compete=sp.TBool)), playerPoints=sp.map(tkey=sp.TNat, tvalue=sp.TRecord( points=sp.TNat, rank=sp.TNat)), keysset=sp.set([admin]), )
def get_type(): return sp.TRecord(tokens=sp.TSet(t=sp.TNat))
def get_operator_tokens_type(): return sp.TVariant(All_tokens = sp.TUnit, Some_tokens = sp.TSet(token_id_type))
# Counter - Example for illustrative purposes only. import smartpy as sp # Request parameters hash_set_type = sp.TSet(sp.TString) class EthClientOnTezos(sp.Contract): def __init__(self): self.init(storedValue = 0, latest_block =0, sample_hash = sp.string('0x'), # Hash of the header that has the highest cumulative difficulty. The current head of the canonical chain header_hash = sp.string('0x'), # Hashes of the canonical chain mapped to their numbers. Stores up to `hashes_gc_threshold` entries header number -> header hash canonical_header_hashes = sp.map(tkey= sp.TNat , tvalue=sp.TString), # All known header hashes for a block number. Stores up to `finalized_gc_threshold`. # header number -> hashes of all headers with this number. # used in the relayer to backtrack if chain switched the fork. known_hashes = sp.big_map(tkey = sp.TNat, tvalue= hash_set_type), # Number of confirmations that applications can use to consider the transaction safe.For most use cases 25 should be enough, for super safe cases it should be 500. num_confirmations=2 ) # alert("testing log" + self.storage.number)