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)
