def Deploy(provider, location):
"""
Deploy a new SIP provider to the KRYPTON network
:param provider: the address of the SIP provider wallet
:type provider: str
:param location: the (DNS SRV) location of the outbound proxy
:type location: str
:return: whether the deploy was successful
:rtype: bool
"""
if not CheckWitness(provider):
Log('FORBIDDEN')
return False
context = GetContext()
address = Get(context, provider)
# Deploy the provider
if (address == 0):
Put(context, provider, location)
Log('DEPLOY_SUCCESS')
return True
Log('DEPLOY_FAILED')
return False
def Deploy():
"""
This is used to distribute the initial tokens to the owner
:return: whether the deploy was successful
:rtype: bool
"""
if not CheckWitness(OWNER):
Log("Must be owner to deploy")
return False
context = GetContext()
has_deployed = Get(context, 'initialized')
if has_deployed == 0:
# do deploy logic
Put(context, 'initialized', 1)
Put(context, OWNER, TOTAL_SUPPLY)
return True
Log('Could not deploy')
return False
def buy_product(buyer_address , p_hash):
if not CheckWitness(buyer_address):
Log('FORBIDDEN')
return False
Log('CAN_NOT_BUY_THE_PRODECT')
return False
def Main(alpha, beta: str) -> int:
"""Entry point for the smart contract.
Args:
alpha (str):
UUID used as the first part of the key for Storage.Put().
beta (str):
UUID used as the second part of the key for Storage.Put().
Return:
(int): status code representing if execution was a success.
"""
if not IsUUID(alpha):
Log("'alpha' parameter has an invalid RFC UUID format")
Log(alpha)
return 101
if not IsUUID(beta):
Log("'beta' parameter has an invalid RFC UUID format")
Log(beta)
return 102
context = GetContext()
storageKey = GenerateStorageKey(alpha, beta)
transactionHash = GetTransactionHash()
if len(transactionHash) == 0:
Log("Transaction hash has a length of 0")
return 103
Put(context, storageKey, transactionHash)
return 200
def JudgeInstance(game_type, instance_ts):
if isGameInstanceJudged(game_type, instance_ts):
return "Already Judged"
# Separate Winners from Losers
correct_prediction = GetPrediction(game_type, instance_ts)
n_oracles_for_instance = GetOracleCountForInstance(game_type, instance_ts)
n_correct = 0
total_bounty = 0
index = 0
while index < n_oracles_for_instance:
index = index + 1
oracle = GetOracleAtIndexN(game_type, instance_ts, index)
oracle_prediction = GetOraclePrediction(game_type, instance_ts, oracle)
if oracle_prediction == correct_prediction:
# Add to Winners
# collateral is moved from locked into available
UnlockCollateral(oracle)
n_correct = n_correct + 1
else:
# Add to Losers
# Both Available and Locked Balance is removed and added to Winner collection
oracle_available_balance = GetOracleBalance(oracle)
oracle_locked_balance = GetOracleLockedBalance(oracle)
total_bounty = total_bounty + oracle_available_balance + oracle_locked_balance
WipeOutBalances(oracle)
if n_correct == 0:
return "Nothing correct"
bounty_per_correct_oracle = total_bounty // n_correct
owner_bounty = total_bounty % n_correct
AddBountyForOwner(owner_bounty)
Log("n_correct")
Log(n_correct)
SetCorrectOracleCountForInstance(game_type, instance_ts, n_correct)
# Loop again
index = 0
while index < n_oracles_for_instance:
index = index + 1
oracle = GetOracleAtIndexN(game_type, instance_ts, index)
oracle_prediction = GetOraclePrediction(game_type, instance_ts, oracle)
if oracle_prediction == correct_prediction:
oracle_available_balance = GetOracleBalance(oracle)
oracle_available_balance = oracle_available_balance + bounty_per_correct_oracle
UpdateAvailableBalance(oracle, oracle_available_balance)
sep = "SEPARATOR"
notification = concat(instance_ts, sep)
notification = concat(notification, n_correct)
notification = concat(notification, sep)
notification = concat(notification, correct_prediction)
Notify(notification)
# Set Game to be Judged (no more judging allowed)
SetGameInstanceJudged(game_type, instance_ts)
return True
def Main(operation, args):
Log(args)
trigger = GetTrigger()
storage = StorageAPI()
arg_error = 'Incorrect Arg Length'
if trigger == Verification():
# todo maybe implement later
return True
elif trigger == Application():
if operation != None:
if operation == "balance":
if len(args) == 1:
account = args[0]
balance = storage.get(account)
return balance
Log(arg_error)
return arg_error
if operation == "accrue":
if len(args) == 2:
account = args[0],
gain = args[1]
new_balance = storage.get(account) + gain
return storage.put(account, new_balance)
Log(arg_error)
return arg_error
return False
def Unregister(user):
"""
Unregister a user from the KRYPTON network
:param user: the public address of the user
:type user: str
:return: whether the registration was successful
:rtype: bool
"""
# Check if the user is validating the transaction
if not CheckWitness(user):
Log('FORBIDDEN')
return False
context = GetContext()
uuid = Get(context, user)
if not (uuid == 0):
# Remove registration
Delete(context, user)
Delete(context, uuid)
Log('UNREGISTER_SUCCESS')
return True
# No registration found
Log('UNREGISTER_FAILED')
return False
def Undeploy(provider):
"""
Undeploy a provider from the KRYPTON network
:param provider: the address of the SIP provider wallet
:type provider: str
:return: whether the deploy was successful
:rtype: bool
"""
if not CheckWitness(provider):
Log('FORBIDDEN')
return False
context = GetContext()
address = Get(context, provider)
# Remove deployment
if not (address == 0):
Delete(context, provider)
Log('UNDEPLOY_SUCCESS')
return True
# No deployment found
Log('UNDEPLOY_FAILED')
return False
def RefundPromo(buyer, promo_id):
"""
Refund all of buyer's purchased tickets for specified promo
Args:
buyer (str): buyer's public key
promo_id (str): promo unique id
Returns:
(bool): True if successfully refunded
"""
#
# Checks for if args are valid and refund conditions are met
#
promo = get_promo_storage_keys(promo_id)
promo_exists = IsPromoExist(promo_id)
expired = IsPromoExpired(promo_id)
context = GetContext()
min_count = Get(context, promo.min_count_key)
purchased_count = Get(context, promo.purchased_count_key)
count_met = purchased_count >= min_count
if promo_exists:
# Cannot issue refund if minimum number of tickets has been sold past deadline
if expired and count_met:
Log('Refund no longer allowed, promo refund deadline has passed and the minimum number of tickets has been sold'
)
return False
buyer_key = concat(promo_id, buyer)
refund_quantity = Get(context, buyer_key)
if not refund_quantity:
Log('No purchases found using given public key and promo_id')
return False
#
# Refund tickets
#
Delete(context, buyer_key)
price_per_person = Get(context, promo.price_per_person_key)
refund_amount = refund_quantity * price_per_person
refund_address = GetCallingScriptHash()
OnRefund(refund_address, refund_amount)
# update purchased_count
purchased_count -= refund_quantity
Put(context, promo.purchased_count_key, purchased_count)
return True
def GetCurrentMax(game_type, instance_ts):
k1 = concat(key_prefix_game_type, game_type)
k2 = concat(key_prefix_game_instance, instance_ts)
k12 = concat(k1, k2)
key = concat(k12, key_prefix_game_instance_max)
context = GetContext()
v = Get(context, key)
Log(key)
Log(v)
return v
def GetKey(key):
msg = concat("Get key: ", key)
Log(msg)
#get key
context = GetContext()
data = Get(context, key)
msg = concat("Data found: ", data)
Log(msg)
return data
def DoTransfer(t_from, t_to, amount):
"""
Method to transfer NEP5 tokens of a specified amount from one account to another
:param t_from: the address to transfer from
:type t_from: bytearray
:param t_to: the address to transfer to
:type t_to: bytearray
:param amount: the amount of NEP5 tokens to transfer
:type amount: int
:return: whether the transfer was successful
:rtype: bool
"""
if amount <= 0:
Log("Cannot transfer negative amount")
return False
from_is_sender = CheckWitness(t_from)
if not from_is_sender:
Log("Not owner of funds to be transferred")
return False
if t_from == t_to:
Log("Sending funds to self")
return True
context = GetContext()
from_val = Get(context, t_from)
if from_val < amount:
Log("Insufficient funds to transfer")
return False
if from_val == amount:
Delete(context, t_from)
else:
difference = from_val - amount
Put(context, t_from, difference)
to_value = Get(context, t_to)
to_total = to_value + amount
Put(context, t_to, to_total)
OnTransfer(t_from, t_to, amount)
return True
def DoTransfer(sender, receiver, amount):
"""
Method to transfer tokens from one account to another
:param sender: the address to transfer from
:type sender: bytearray
:param receiver: the address to transfer to
:type receiver: bytearray
:param amount: the amount of tokens to transfer
:type amount: int
:return: whether the transfer was successful
:rtype: bool
"""
if amount <= 0:
Log("Cannot transfer negative amount")
return False
from_is_sender = CheckWitness(sender)
if not from_is_sender:
Log("Not owner of funds to be transferred")
return False
if sender == receiver:
Log("Sending funds to self")
return True
context = GetContext()
from_val = Get(context, sender)
if from_val < amount:
Log("Insufficient funds to transfer")
return False
if from_val == amount:
Delete(context, sender)
else:
difference = from_val - amount
Put(context, sender, difference)
to_value = Get(context, receiver)
to_total = to_value + amount
Put(context, receiver, to_total)
DispatchTransferEvent(sender, receiver, amount)
return True
def ResultNotice(agreement_key, weather_param, oracle_cost):
"""
Method to signal resulte by oracle
:param agreement_key: the key of the agreement
:type agreement_key: bytearray
:param weather_param: weather parameter that the contract is depending on
:type weather_param: int
:param oracle_cost: costs made by the oracle to do this assignment
:type oracle_cost: int
:return: whether a pay out to the customer is done
:rtype: bool
"""
# Check if the method is triggered by the oracle for this agreement
context = GetContext()
agreement_data = Get(context, agreement_key)
oracle = agreement_data[8]
if not CheckWitness(oracle):
Log("Must be oracle to notice results")
return False
timestamp = agreement_data[3]
utc_offset = agreement_data[4]
status = agreement_data[12]
if not status == 'initialized':
Log("Contract has incorrect status to do a result notice")
return False
agreement_data[12] = 'result-noticed'
agreement_data[13] = weather_param
agreement_data[14] = oracle_cost
# Get timestamp of current block
currentHeight = GetHeight()
currentBlock = GetHeader(currentHeight)
current_time = currentBlock.Timestamp
Put(context, agreement_key, agreement_data)
timezone_timestamp = timestamp + (3600 * utc_offset)
timezone_current_time = current_time + (3600 * utc_offset)
if timezone_current_time < timezone_timestamp:
Log("Datetime of result notice is lower than agreed datetime")
return False
else:
DispatchResultNoticeEvent(agreement_key, weather_param, oracle_cost)
return True
def DoTransferFrom(t_from, t_to, amount):
"""
Method to transfer NEP5 tokens of a specified amount from one account to another
:param t_from: the address to transfer from
:type t_from: bytearray
:param t_to: the address to transfer to
:type t_to: bytearray
:param amount: the amount of NEP5 tokens to transfer
:type amount: int
:return: whether the transfer was successful
:rtype: bool
"""
if amount <= 0:
return False
context = GetContext()
allowance_key = concat(t_from, t_to)
available_to_to_addr = Get(context, allowance_key)
if available_to_to_addr < amount:
Log("Insufficient funds approved")
return False
from_balance = Get(context, t_from)
if from_balance < amount:
Log("Insufficient tokens in from balance")
return False
to_balance = Get(context, t_to)
# calculate the new balances
new_from_balance = from_balance - amount
new_to_balance = to_balance + amount
new_allowance = available_to_to_addr - amount
# persist the new balances
Put(context, allowance_key, new_allowance)
Put(context, t_to, new_to_balance)
Put(context, t_from, new_from_balance)
Log("transfer complete")
# dispatch transfer event
OnTransfer(t_from, t_to, amount)
return True
def do_current_timestamp() -> bytearray:
Log('do_current_timestamp triggered.')
current_height = GetHeight()
Log('current_height:')
Log(current_height)
current_block = GetHeader(current_height)
# Log('current_block:')
# Log(current_block)
timestamp = current_block.Timestamp
Log('timestamp:')
Log(timestamp) # Example b'\xc1\xc7|Z'
return timestamp
def do_get_timestamp(args: list) -> bytearray:
Log('do_get_timestamp triggered.')
if len(args) > 0:
height = args[0]
Log('height:')
Log(height)
header = GetHeader(height)
timestamp = header.Timestamp
Log('timestamp:')
Log(timestamp)
return timestamp
Notify('invalid argument length')
return False
def do_get_next_consensus(args: list) -> bytearray:
Log('do_get_next_consensus triggered.')
if len(args) > 0:
height = args[0]
Log('height:')
Log(height)
header = GetHeader(height)
next_consensus = header.NextConsensus
Log('next_consensus:')
Log(next_consensus)
return next_consensus
Notify('invalid argument length')
return False
def do_get_block_hash(args: list) -> bytearray:
Log('do_get_block_hash triggered.')
if len(args) > 0:
height = args[0]
Log('height:')
Log(height)
header = GetHeader(height)
# version = GetVersion(header)
hash_val = GetHash(header)
Log('hash_val:')
Log(hash_val)
return hash_val
Notify('invalid argument length')
return False
def own_area(owner_address, lat, lon):
if not CheckWitness(owner_address):
Log('FORBIDDEN')
return False
address = Get(context, owner_address)
location = [lat, lon]
if (address == 0):
Put(context, owner_address, location)
Log('owned_success')
return True
return False
def Deploy(dapp_name, oracle, time_margin, min_time, max_time):
"""
Method for the dApp owner initiate settings in storage
:param dapp_name: name of the dapp
:type dapp_name: str
:param oracle: oracle that is used
:type oracle: bytearray
:param time_margin: time margin in seconds
:type time_margin: int
:param min_time: minimum time until the datetime of the event in seconds
:type min_time: int
:param max_time: max_time until the datetime of the event in seconds
:type max_time: int
:return: whether the update succeeded
:rtype: bool
"""
if not CheckWitness(OWNER):
Log("Must be owner to deploy dApp")
return False
context = GetContext()
Put(context, 'dapp_name', dapp_name)
Put(context, 'oracle', oracle)
if time_margin < 0:
Log("time_margin must be positive")
return False
Put(context, 'time_margin', time_margin)
if min_time < 3600 + time_margin:
Log("min_time must be greater than 3600 + time_margin")
return False
Put(context, 'min_time', min_time)
if max_time <= (min_time + time_margin):
Log("max_time must be greather than min_time + time_margin")
return False
Put(context, 'max_time', max_time)
return True
def CreateNewGameInstance(client_hash, game_type, instance_ts):
if isGameInstanceLive(game_type, instance_ts):
return "Game Instance is Already Live"
else:
k1 = concat(key_prefix_game_type, game_type)
k2 = concat(key_prefix_game_instance, instance_ts)
key = concat(k1, k2)
context = GetContext()
Log(key)
Put(context, key, client_hash)
key_hash = concat(key, client_hash)
Log(key_hash)
#Notify(key_hash)
return "Success"
def CheckTimestamp(timestamp_normalised):
# Checks if TS() > T_n + deadline
height = GetHeight()
hdr = GetHeader(height)
ts = GetTimestamp(hdr)
Log(ts)
Log(timestamp_normalised)
nd = ts - deadline
Log(nd)
diff = nd - timestamp_normalised
Log(diff)
if nd > timestamp_normalised:
return True
return False
def DoApprove(t_owner, t_spender, amount):
"""
Method by which the owner of an address can approve another address
( the spender ) to spend an amount
:param t_owner: Owner of tokens
:type bytearray
:param t_spender: Requestor of tokens
:type bytearray
:param amount: Amount requested to be spent by Requestor on behalf of owner
:type bytearray
:return: success of the operation
:rtype: bool
"""
owner_is_sender = CheckWitness(t_owner)
if not owner_is_sender:
Log("Incorrect permission")
return False
context = GetContext()
from_balance = Get(context, t_owner)
# cannot approve an amount that is
# currently greater than the from balance
if from_balance >= amount:
approval_key = concat(t_owner, t_spender)
current_approved_balance = Get(context, approval_key)
new_approved_balance = current_approved_balance + amount
Put(context, approval_key, new_approved_balance)
Log("Approved")
OnApprove(t_owner, t_spender, amount)
return True
return False
def Main(operation, args):
"""
:param operation: str The name of the operation to perform
:param args: list A list of arguments along with the operation
"""
if operation == 'GetVersion':
# very simple method to test the contract
Log("Invoked GetVersion")
return BZSVERSION
# Am I who I say I am? args[0] musth be the wallet hash code
ontid = args[0]
authorized = CheckWitness(ontid)
if not authorized:
Log("Not Authorized")
return 'Not Authorized'
Log(ontid)
# storage operations
if operation == 'Store':
if len(args) < 4:
return 'Invalid arguments'
category = args[1]
id = args[2]
value = args[3]
put(category, id, value)
#Notify(['Store:', category, id])
return 'OK'
if operation == 'Retrieve':
if len(args) < 3:
return 'Invalid arguments'
category = args[1]
id = args[2]
data = get(category, id)
#Notify(['Retrieve:', category, id])
return data
if operation == 'Delete':
if len(args) < 3:
return 'Invalid arguments'
category = args[1]
id = args[2]
delete(category, id)
#Notify(['Delete:', category, id])
return 'OK'
return 'Invalid operation'
def ClaimFunds(promo_id):
"""
Creator of promo can claim funds from promo_id if the min_count and
expiration conditions are met. Funds can only be claimed if wallet's public
key used to invoke matches the public key used in create.
Args:
promo_id (str): promo unique id
Returns:
(bool): True if promo claimed successfully
"""
#
# Checks for if args are valid and claim conditions are met
#
promo_exists = IsPromoExist(promo_id)
if not promo_exists:
Log('Promo not found')
return False
expired = IsPromoExpired(promo_id)
if not expired:
Log('Promo not over yet! Cannot claim funds yet')
return False
promo = get_promo_storage_keys(promo_id)
context = GetContext()
min_count = Get(context, promo.min_count_key)
purchased_count = Get(context, promo.purchased_count_key)
if purchased_count < min_count:
Log('Not enough tickets were sold by deadline, buyers can claim refund'
)
return False
#
# Claim funds
#
price_per_person = Get(context, promo.price_per_person_key)
funds_amount = purchased_count * price_per_person
claim_address = GetCallingScriptHash()
OnClaim(claim_address, funds_amount)
return True
def QueryUser(query, user):
"""
Query a user on the KRYPTON network
:param query: type of query is UUID or provider
:type query: str
:param user: the public address of the user
:type user: str
:return: whether the query was successful
:rtype: bool
"""
context = GetContext()
uuid = Get(context, user)
if (uuid == 0):
Log('QUERY_USER_FAILED')
return False
if (query == "uuid"):
Notify(uuid)
return True
provider = Get(context, uuid)
if (provider == 0):
Log('QUERY_PROVIDER_FAILED')
return False
if (query == "provider"):
Notify(provider)
return True
location = Get(context, provider)
if (location == 0):
Log('QUERY_LOCATION_FAILED')
return False
if (query == "location"):
Notify(location)
return True
# User or data not found
Log('QUERY_FAILED')
return False
def own_area(owner_address, lat, lon):
if not CheckWitness(owner_address):
Log('ALREADY')
return False
context = GetContext()
address = Get(context, owner_address)
obj = [lat, lon]
location = _data_packing(obj)
if (address == 0):
Put(context, owner_address, location)
Log('owned_success')
return True
return False
def CheckTiming(timestamp_normalised):
# Check T_n relative to current TS()
height = GetHeight()
hdr = GetHeader(height)
ts = GetTimestamp(hdr)
Log(ts)
t_n_plus_one = timestamp_normalised + Game_rules.timestep
Log(t_n_plus_one)
Log(timestamp_normalised)
if ts > t_n_plus_one:
return 1 # expired
elif ts < timestamp_normalised:
return 2 # too early to submit, ignore
else:
return 0 # all good
def Register(user, provider, uuid):
"""
Register a user with a provider and use the provided UUID as
authorization nonce
:param user: the public address of the user
:type user: str
:param provider: the public address of the provider
:type provider: str
:param uuid: the UUID supplied by provider and confirmed by user
:type uuid: str
:return: whether the registration was successful
:rtype: bool
"""
# Check if the UUID format is validating
if not (CheckUUID(uuid)):
return False
# Check if the user is validating the transaction
if not CheckWitness(user):
Log('FORBIDDEN')
return False
context = GetContext()
address = Get(context, provider)
# Check if provider exists
if (address == 0):
Log('PROVIDER_ABSENT')
return False
address = Get(context, user)
# Remove old registration before inserting new registration
if not (address == 0):
Delete(context, user)
Delete(context, uuid)
Log('UNREGISTER_SUCCESS')
# Store new registration
Put(context, user, uuid)
Put(context, uuid, provider)
Log('REGISTER_SUCCESS')
return True
