def CheckHashExist(args):
if len(args) != 1:
return False
inputHash = args[0]
exist = Get(GetContext(), inputHash)
return exist + 0
def cancelRequest(requestId, payment, callBackFunc, expiration):
assert (CheckWitness(OWNER))
chainlinkClient = Get(GetContext(), CHAINLINK_CLIENT)
assert (DynamicCallFunction(
bytearray_reverse(chainlinkClient), 'cancelChainlinkRequest',
[OWNER, requestId, payment, callBackFunc, expiration]))
return True
def setFeePercentage(feePercentage):
RequireWitness(Operater)
Require(feePercentage <= 100)
Require(feePercentage >= 0)
Put(GetContext(), FEE_PERCENTAGE_KEY, feePercentage)
Notify(["setFeePercentage", feePercentage])
return True
def init(_caller, _cut):
ctx = GetContext()
Put(ctx, INIT, 'TRUE')
Put(ctx, _cut, 'TRUE')
_cut = _concatkey(_caller, _cut)
Put(ctx, _cut, 'TRUE')
return True
def approve(owner, spender, tokenId, amount):
"""
approve amount of the tokenId token to toAcct address, it can overwrite older approved amount
:param owner:
:param spender:
:param tokenId:
:param amount:
:return:
"""
assert (_whenNotPaused())
# make sure the invoker is the owner address
assert (CheckWitness(owner))
# make sure the address is legal
assert (len(spender) == 20)
assert (_tokenExist(tokenId))
ownerBalance = balanceOf(owner, tokenId)
# you can use "if" to notify the corresponding message, or use assert to raise exception
assert (ownerBalance >= amount)
assert (amount > 0)
key = _concatkey(_concatkey(_concatkey(APPROVE_PREFIX, tokenId), owner), spender)
Put(GetContext(), key, amount)
ApprovalEvent(owner, spender, tokenId, amount)
return True
def approve(owner, spender, tokenId, amount):
"""
approve amount of the tokenId token to toAcct address, it can overwrite older approved amount
:param owner:
:param spender:
:param tokenId:
:param amount:
:return:
"""
res = int(owner)
RequireWitness(owner)
RequireScriptHash(owner)
RequireScriptHash(spender)
Require(checkTokenId(tokenId))
ownerBalance = balanceOf(owner, tokenId)
# you can use "if" to notify the corresponding message, or use Require to raise exception
Require(ownerBalance >= amount)
Require(amount > 0)
key = concatkey(concatkey(concatkey(tokenId, APPROVE), owner), spender)
Put(GetContext(), key, amount)
ApprovalEvent(owner, spender, tokenId, amount)
return True
def balanceOf(account):
"""
:param account:
:return: the token balance of account
"""
assert (len(account) == 20)
return Get(GetContext(), concat(BALANCE_PREFIX, account))
def getDiskIdList(gameId):
diskIdListInfo = Get(GetContext(),
concatKey(GAME_DISKID_LIST_PREFIX, gameId))
if not diskIdListInfo:
return []
else:
return Deserialize(diskIdListInfo)
def canPlaceBet(gameId):
"""
:param gameId:
:return: False means can NOT place bets, True means CAN place bets.
"""
return GetTime() < Get(GetContext(),
concatKey(GAME_BET_ENDTIME_PREFIX, gameId))
def transferOwnership(newOwner):
oldOwner = getOwner()
assert (CheckWitness(oldOwner))
assert (len(newOwner) == 20 and newOwner != ZERO_ADDRESS)
Put(GetContext(), OWNER_KEY, newOwner)
TransferOwnershipEvent(oldOwner, newOwner)
return True
def resetGameBetEndTime(gameId, newBetEndTime):
RequireWitness(Operater)
Require(getGameBetEndTime(gameId) > 0)
Put(GetContext(), concatKey(GAME_BET_ENDTIME_PREFIX, gameId),
newBetEndTime)
Notify(["resetBetEndTime", gameId, newBetEndTime])
return True
def setDev1Percentage(dev1Percentage):
RequireWitness(Dev1)
Require(dev1Percentage <= 100)
Require(dev1Percentage >= 0)
Put(GetContext(), DEV1_PERCENTAGE_KEY, dev1Percentage)
Notify(["setDev1Percentage", dev1Percentage])
return True
def fulfill(requestId, price):
assert (ChainlinkClientCall(
'recordChainlinkFulfillment',
[bytearray_reverse(GetCallingScriptHash()), requestId]))
# Notify(['test'])
Put(GetContext(), CURRENT_PRICE, price)
return True
def getContractAddrWithChainId(toChainId):
"""
return the asset contract hash of btc in 'toChainId' blockchain
:param toChainId: this parameter is in integer format
:return: the asset contract hash of btc in 'toChainId' blockchain, returned value is in hex format
"""
return Get(GetContext(), concat(CONTRACT_HASH, toChainId))
def oracleRequest(spender, payment, specId, callbackAddress,
callbackFunctionId, nonce, dataVersion, data,
callFunctionId):
onlyLINK()
RequireWitness(spender)
payment = payment + 0
# TODO
requestId = sha256(Serialize([callbackAddress, spender, nonce]))
assert (not Get(GetContext(), concatKey(COMMITMENTS_PRIFX, requestId)))
expiration = GetTime() + EXPIRY_TIME
Put(GetContext(), concatKey(COMMITMENTS_PRIFX, requestId),
Serialize([payment, callbackAddress, callbackFunctionId, expiration]))
OracleRequestEvent(specId, spender, requestId, payment, callbackAddress,
callbackFunctionId, expiration, dataVersion, data,
callFunctionId)
return True
def StoreUsedNum(args):
if len(args) != 3:
return False
addr = Get(GetContext(), KeyOwnerAddress)
assert (len(addr) != 0)
assert (CheckWitness(addr))
userId = args[0]
orderId = args[1]
usedNum = args[2]
t = concat(KeyPrefix, userId)
KEY = concat(t, orderId)
Put(GetContext(), KEY, usedNum)
Notify([userId, orderId, usedNum])
return True
def balanceOf(acct, tokenId):
"""
get balance of account in terms of token with the tokenId
:param acct: used to check the acct balance
:param tokenId: the tokenId determines which token balance of acct needs to be checked
:return: the balance of acct in terms of tokenId tokens
"""
return Get(GetContext(), _concatkey(_concatkey(BALANCE_PREFIX, tokenId), acct))
def burn(amount):
"""
Burns the amount of Minglechain token from the owner's address.
:param _amount: MC amount to burn.
"""
# only owner can burn the token
assert (CheckWitness(OWNER))
ownerBalance = balanceOf(OWNER)
total = totalSupply()
assert (total >= amount and ownerBalance >= amount and amount >= 0)
newTotal = total - amount
# update total supply
Put(GetContext(), SUPPLY_KEY, newTotal)
# update the owner's balance
Put(GetContext(), concat(BALANCE_PREFIX, OWNER), ownerBalance - amount)
TransferEvent(OWNER, "", amount)
return True
def init(_caller, _cut):
ctx = GetContext()
Put(ctx, _cut, 'TRUE')
_cut = _concatkey(_caller, _cut)
Put(ctx, _cut, 1)
a = Get(ctx, _cut)
c = 20 / a
return True
def setFeeCollector(feeCollector):
"""
:param feeCollector: address
:return:
"""
assert (CheckWitness(getOwner()))
Put(GetContext(), FEE_COLLECTOR_KEY, feeCollector)
return True
def init():
# init list
list1 = [1,2,3]
list1Info = Serialize(list1)
Put(GetContext(), LISTKEY, list1Info)
# init map
map1 = {
"key1":1,
"key2":2
}
map1Info = Serialize(map1)
Put(GetContext(), MAPKEY, map1Info)
Notify(["init list is ",list1])
Notify(["init map is ", map1["key1"], map1["key2"]])
return True
def checkIn(address, userId):
assert (CheckWitness(address))
checkInDays = canCheckIn(address)
assert (checkInDays > 0)
Put(GetContext(), concat(PLAYER_LAST_CHECK_IN_DAY, address), checkInDays)
Notify(["checkIn", address, userId, GetTime()])
return True
def setLockProxy(lockProxy):
"""
:param lockProxy: ont lock proxy
:return:
"""
assert (CheckWitness(getOwner()))
Put(GetContext(), LOCK_PROXY_KEY, bytearray_reverse(lockProxy))
return True
def getSaltAfterEnd(gameId):
"""
can only get game's salt after end
:param gameId: game's id
:return: salt number
"""
salt = Get(GetContext(), concatKey(gameId, GAME_SALT_KEY))
return salt
def removeAuthorizedLevel(account):
RequireWitness(CEOAddress)
Require(len(account) == 20)
# make sure account is authorized before.
Require(isAuthorizedLevel(account))
Delete(GetContext(), _concatkey(AUTHORIZED_LEVEL_PREFIX, account))
Notify(["removeAuthorizedLevel", account])
return True
def getDiskPlayersList(diskId, betStatus):
playersListInfo = Get(
GetContext(),
concatKey(concatKey(DISK_BET_PLAYER_LIST_PREFIX, diskId), betStatus))
if not playersListInfo:
return []
else:
return Deserialize(playersListInfo)
def fulfillOracleRequest(node, requestId, payment, callbackAddress,
callbackFunctionId, expiration, data):
RequireWitness(node)
onlyAuthorizedNode(node)
expiration = expiration + 0
payment = payment + 0
paramsHash = Serialize(
[payment, callbackAddress, callbackFunctionId, expiration])
assert (Get(GetContext(), concatKey(COMMITMENTS_PRIFX,
requestId)) == paramsHash)
Put(GetContext(), WITHDRAWABLETOKENS,
Get(GetContext(), WITHDRAWABLETOKENS) + payment)
Delete(GetContext(), concatKey(COMMITMENTS_PRIFX, requestId))
assert (callBackFunction(callbackAddress, callbackFunctionId, requestId,
data))
return True
def updateState(stateRootHash, height, version, depositIds, withdrawAmounts,
toAddresses, assetAddresses):
operator = Get(GetContext(), OPERATOR_ADDRESS)
assert (CheckWitness(operator))
preHeight = Get(GetContext(), CURRENT_HEIGHT)
assert (preHeight + 1 == height)
Put(GetContext(), CURRENT_HEIGHT, height)
stateRoot = [stateRootHash, height, version]
stateRootInfo = Serialize(stateRoot)
Put(GetContext(), concatKey(Current_STATE_PREFIX, height), stateRootInfo)
# 返回满足条件用户的钱
currentWithDrawId = Get(GetContext(), CURRENT_WITHDRAW_ID)
confirmHeight = Get(GetContext(), CONFRIM_HEIGHT)
if currentWithDrawId:
while currentWithDrawId > 1:
withdrawStatusInfo = Get(
GetContext(), concatKey(WITHDRAW_PREFIX,
currentWithDrawId - 1))
withdrawStatus = Deserialize(withdrawStatusInfo)
if (height - withdrawStatus[3] == confirmHeight):
assert (withdraw(withdrawStatus[0]))
elif height - withdrawStatus[3] > confirmHeight:
break
currentWithDrawId = currentWithDrawId - 1
# 更新deposit状态
_updateDepositState(depositIds)
# 更新withdraw状态
_createWithdrawState(height, withdrawAmounts, toAddresses, assetAddresses)
Notify([
'updateState', stateRootHash, height, version, depositIds,
withdrawAmounts, toAddresses, assetAddresses
])
return True
def getGP(gpId):
gpMapInfo = Get(GetContext(), _concatkey(GP_PREFIX, gpId))
if not gpMapInfo:
return []
gpMap = Deserialize(gpMapInfo)
price = gpMap["price"]
contentInfo = gpMap["content"]
content = Deserialize(contentInfo)
return [price, content]
def checkIn(account):
assert (CheckWitness(account))
checkInDays = canCheckIn(account)
if (checkInDays > 0):
_transferTokenTo(account, 100 * OEP4TokenMagnitude)
_chargeONG(account, Fee)
Put(GetContext(), concatKey(PLAYER_LAST_CHECK_IN_DAY, account), checkInDays)
Notify(["checkIn", account])
return True
