def transferProperty(transferList):
"""
:param transferList: [[toAccount1, DNA1],[toAccount2, DNA2]]
:return: bool
"""
DNACheck = transferList[0][1]
account = Get(context, concatKey(DNA_PRE_KEY, DNACheck))
RequireWitness(account)
for transferE in transferList:
toAccount = transferE[0]
DNA = transferE[1]
DNAlist = Get(context, concatKey(PLAYER_ADDRESS_PRE_KEY, account))
DNAlist = Deserialize(DNAlist)
toDNAlist = Get(context, concatKey(PLAYER_ADDRESS_PRE_KEY, toAccount))
if not toDNAlist:
toDNAlist = []
else:
toDNAlist = Deserialize(DNAlist)
num = 0
while num < len(DNAlist):
if DNAlist[num] == DNA:
Put(context, concatKey(DNA_PRE_KEY, DNA), toAccount)
DNAlist.remove(num)
toDNAlist.append(DNA)
Put(context, concatKey(PLAYER_ADDRESS_PRE_KEY, account),
Serialize(DNAlist))
Put(context, concatKey(PLAYER_ADDRESS_PRE_KEY, toAccount),
Serialize(toDNAlist))
num += 1
Notify(["Transfer property successfully"])
return True
def createProperty(createList):
"""
:param createList: [[account1, DNA1],[account2, DNA2]]
:return: bool
"""
RequireWitness(Owner)
for createE in createList:
account = createE[0]
DNA = createE[1]
accountCheck = Get(context, concatKey(DNA_PRE_KEY, DNA))
Require(len(account) == 20)
Require(DNA > 100000000000000)
Require(DNA < 1000000000000000)
Require(not accountCheck)
DNAlist = Get(context, concatKey(PLAYER_ADDRESS_PRE_KEY, account))
if not DNAlist:
DNAlist = []
else:
DNAlist = Deserialize(DNAlist)
DNAlist.append(DNA)
Put(context, concatKey(DNA_PRE_KEY, DNA), account)
Put(context, concatKey(PLAYER_ADDRESS_PRE_KEY, account),
Serialize(DNAlist))
Notify(["Create property successfully."])
return True
def registerDomain(fulldomain, registerdid, idx, validto):
'''
register domain
fulldomain: domain string
registerdid: register ontid
idx:owner walletid
validto : valid period
'''
currenttime = GetTime()
if validto > 0:
assert (validto > currenttime)
assert (len(fulldomain) > 0)
_validateDNSName(fulldomain)
lowerdomain = lower(fulldomain)
assert (not ownerOf(lowerdomain))
_checkParentAuth(lowerdomain, idx)
Put(ctx, _concatkey(OWNER_KEY, lowerdomain), registerdid)
Put(ctx, _concatkey(VALID_KEY, lowerdomain), validto)
recordskey = _concatkey(RECORDS_KEY, registerdid)
records = Get(ctx, recordskey)
if not records:
records = [lowerdomain]
else:
records = Deserialize(records)
records.append(lowerdomain)
assert (len(records) <= MAX_COUNT)
Put(ctx, recordskey, Serialize(records))
RegisterDomainEvent(lowerdomain, registerdid, validto)
return True
def addAdmin(Account):
"""
:param Account: new admin's address
:return:
"""
RequireWitness(Owner)
adminList = Get(context, ADMIN_ADDRESS_KEY)
adminList = Deserialize(adminList)
adminList.append(Account)
Put(context, ADMIN_ADDRESS_KEY, Serialize(adminList))
Notify(["Now admin address is", adminList])
return True
def createProperty(Account, createList):
"""
only contract owner or admin can create property
cannot create more than 1000 property once
:param createList: [Account, [[account1, DNA1],[account2, DNA2]]]
:return: bool
"""
Require(Get(context, concatKey(ADMIN_ADDRESS_KEY, Account)) == 1)
RequireWitness(Account)
DNAlist = Get(context, concatKey(PLAYER_ADDRESS_PRE_KEY, createList[0][0]))
if not DNAlist:
DNAlist = []
else:
DNAlist = Deserialize(DNAlist)
Require(len(createList) <= 1000)
for createE in createList:
account = createE[0]
DNA = createE[1]
accountCheck = Get(context, concatKey(DNA_PRE_KEY, DNA))
Require(len(account) == 20)
# check len
Require(DNA >= 100000000000000)
Require(DNA < 10000000000000000)
# check kind
Require(Div(DNA, 100000000000000) % 100 > 0)
Require(Div(DNA, 100000000000000) % 100 < 100)
# check grade
Require(Div(DNA, 1000000000000) % 100 > 0)
Require(Div(DNA, 1000000000000) % 100 < 100)
# check name
Require(Div(DNA, 1000000000) % 1000 > 0)
Require(Div(DNA, 1000000000) % 1000 < 1000)
# check number
Require(Div(DNA, 1000) % 1000000 > 0)
Require(Div(DNA, 1000) % 1000000 < 1000000)
# check random
Require(DNA % 1000 >= 0)
Require(DNA % 1000 < 1000)
# check DNA
Require(not accountCheck)
DNAlist.append(DNA)
Put(context, concatKey(DNA_PRE_KEY, DNA), account)
Put(context, concatKey(PLAYER_ADDRESS_PRE_KEY, account), Serialize(DNAlist))
Notify(["Create property successfully."])
return True
def transferProperty(transferList):
"""
one account can transfer many DNA to different other accounts
:param transferList: [[toAccount1, DNA1],[toAccount2, DNA2]]
:return: bool
"""
DNACheck = transferList[0][1]
account = Get(context, concatKey(DNA_PRE_KEY, DNACheck))
RequireScriptHash(account)
RequireWitness(account)
DNAlist = Get(context, concatKey(PLAYER_ADDRESS_PRE_KEY, account))
DNAlist = Deserialize(DNAlist)
transferListLen = len(transferList)
transferListIndex = 0
while transferListIndex < transferListLen:
toAccount = transferList[transferListIndex][0]
DNA = transferList[transferListIndex][1]
toDNAlist = Get(context, concatKey(PLAYER_ADDRESS_PRE_KEY, toAccount))
if not toDNAlist:
toDNAlist = []
else:
toDNAlist = Deserialize(toDNAlist)
findInList = _findInList(DNA, DNAlist)
if findInList >= 0:
Put(context, concatKey(DNA_PRE_KEY, DNA), toAccount)
toDNAlist.append(DNA)
DNAlist.remove(findInList)
else:
raise Exception("Not found DNA to be removed")
transferListIndex += 1
Put(context, concatKey(PLAYER_ADDRESS_PRE_KEY, account), Serialize(DNAlist))
Put(context, concatKey(PLAYER_ADDRESS_PRE_KEY, toAccount), Serialize(toDNAlist))
Notify(["Transfer property successfully"])
return True
