def SubmitPrediction(oracle, game_type, instance_ts, prediction):
if not isGameInstanceLive(game_type, instance_ts):
return "Game Instance not yet commissioned"
if isGameInstanceJudged(game_type, instance_ts):
return "Game Instance already judged"
if CheckTimestamp(instance_ts):
return JudgeInstance(game_type, instance_ts) # Too late to submit, but can judge
else:
# Check if Oracle already registered
if isOracleRegisteredForInstance(oracle, game_type, instance_ts):
return "Already registered"
current_oracle_balance = GetOracleBalance(oracle)
n_oracles_for_instance = GetOracleCountForInstance(game_type, instance_ts)
# See if the agent has sent any NEO-GAS assets
tx = GetScriptContainer()
refs = tx.References
if len(refs) < 1:
if current_oracle_balance >= collateral_requirement:
new_count = n_oracles_for_instance + 1
RegisterOracle(game_type, instance_ts, oracle, new_count)
else:
# No assets sent and existing balance too low
return "Not enough balance to register"
else:
ref = refs[0]
sentAsset = GetAssetId(ref)
#sender_hash = GetScriptHash(ref)
if sentAsset == GAS_ASSET_ID:
receiver = GetExecutingScriptHash()
totalGasSent = 0
cOutputs = len(tx.Outputs)
for output in tx.Outputs:
Log(output.Value)
shash = GetScriptHash(output)
if shash == receiver:
totalGasSent = totalGasSent + output.Value
if totalGasSent == b'\x00e\xcd\x1d':
current_oracle_balance = current_oracle_balance + totalGasSent
key = concat(key_prefix_agent_available_balance, oracle)
# Updates Balance of Oracle
context = GetContext()
Put(context, key, current_oracle_balance)
new_count = n_oracles_for_instance + 1
RegisterOracle(game_type, instance_ts, oracle, new_count)
else:
return "Wrong amount of NEO GAS Sent"
# Now to submit prediction if no errors
RegisterPrediction(game_type, instance_ts, oracle, prediction)
p_count = IncrementCountForPrediction(game_type, instance_ts, prediction)
max_so_far = GetCurrentMax(game_type, instance_ts)
if p_count > max_so_far:
# New Current Winner
UpdateMaxVotes(game_type, instance_ts, p_count)
UpdatePrediction(game_type, instance_ts, prediction)
if CheckTimestamp(instance_ts):
return JudgeInstance(game_type, instance_ts)
return True
def get_asset_attachments_for_prev() -> Attachments:
attachment = Attachments()
tx = GetScriptContainer() # type:Transaction
sent_amount_neo = 0
sent_amount_gas = 0
attachment.receiver_addr = GetExecutingScriptHash()
for input in tx.Inputs:
prev_tx = GetTransaction(input.Hash)
references = prev_tx.References
if len(references) > 0:
reference = references[0]
sender_addr = reference.ScriptHash
prev_output = prev_tx.Outputs[input.Index]
if prev_output.ScriptHash == attachment.receiver_addr and prev_output.AssetId == attachment.neo_asset_id:
sent_amount_neo += prev_output.Value
if prev_output.ScriptHash == attachment.receiver_addr and prev_output.AssetId == attachment.gas_asset_id:
sent_amount_gas += prev_output.Value
attachment.neo_attached = sent_amount_neo
attachment.gas_attached = sent_amount_gas
return attachment
def get_asset_attachments() -> Attachments:
attachment = Attachments()
tx = GetScriptContainer() # type:Transaction
references = GetReferences(tx)
attachment.receiver_addr = GetExecutingScriptHash()
m = len(references)
Notify(m)
if len(references) > 0:
reference = references[0]
attachment.sender_addr = reference.ScriptHash
sent_amount_neo = 0
sent_amount_gas = 0
for output in tx.Outputs:
if output.ScriptHash == attachment.receiver_addr and output.AssetId == attachment.neo_asset_id:
sent_amount_neo += output.Value
if output.ScriptHash == attachment.receiver_addr and output.AssetId == attachment.gas_asset_id:
sent_amount_gas += output.Value
print("hello!")
attachment.neo_attached = sent_amount_neo
attachment.gas_attached = sent_amount_gas
return attachment
def Main(operation):
"""
:param operation:
:return:
"""
hash = GetExecutingScriptHash()
Notify(hash)
account = GetAccount(hash)
print("account!")
Notify(account)
print("will get asset")
asset = GetAsset(GAS)
Notify(asset)
print("will get balance")
balance = GetBalance(account, GAS)
Notify(balance)
return operation
def get_asset_attachments() -> Attachments:
"""
Bekommen Sie Informationen über NEO oder Gas das an eine Invocation TX angehängt ist
:return:
Attachments: Ein Objekt mit Informationen über angehängte NEO und GAS
"""
attachment = Attachments()
tx = GetScriptContainer() # type:Transaction
references = tx.References
attachment.receiver_addr = GetExecutingScriptHash()
if len(references) > 0:
reference = references[0]
attachment.sender_addr = reference.ScriptHash
sent_amount_neo = 0
sent_amount_gas = 0
for output in tx.Outputs:
if output.ScriptHash == attachment.receiver_addr and output.AssetId == attachment.neo_asset_id:
sent_amount_neo += output.Value
if output.ScriptHash == attachment.receiver_addr and output.AssetId == attachment.gas_asset_id:
sent_amount_gas += output.Value
attachment.neo_attached = sent_amount_neo
attachment.gas_attached = sent_amount_gas
return attachment
def get_asset_attachments() -> Attachments:
"""
Gets information about NEO and Gas attached to an invocation TX
:return:
Attachments: An object with information about attached neo and gas
"""
attachment = Attachments()
tx = GetScriptContainer()
references = tx.References
attachment.receiver_addr = GetExecutingScriptHash()
if len(references) > 0:
reference = references[0]
attachment.sender_addr = reference.ScriptHash
sent_amount_neo = 0
sent_amount_gas = 0
for output in tx.Outputs:
if output.ScriptHash == attachment.receiver_addr and output.AssetId == attachment.neo_asset_id:
sent_amount_neo += output.Value
if output.ScriptHash == attachment.receiver_addr and output.AssetId == attachment.gas_asset_id:
sent_amount_gas += output.Value
attachment.neo_attached = sent_amount_neo
attachment.gas_attached = sent_amount_gas
return attachment
def DepositNeo():
# get reference to the tx the invocation is in
tx = GetScriptContainer()
references = tx.References
if len(references) < 1:
print("no neo attached")
return False
# we need to determine who sent the tx
reference = references[0]
sender = GetScriptHash(reference)
# this will keep track of how much neo was deposited
value = 0
output_asset_id = GetAssetId(reference)
if output_asset_id != NEO_ASSET_ID:
print("Must deposit NEO")
return False
# this is the contract's address
receiver = GetExecutingScriptHash()
# go through all the outputs
# and check if the receiver is the contract
# if that is true, we add the value of the output to the
# total sum that was deposited
for output in tx.Outputs:
shash = GetScriptHash(output)
if shash == receiver:
output_val = GetValue(output)
value = value + output_val
if value > 0:
print("neo was deposited")
Notify(value)
timestamp = GetHeight()
# now we know value was deposited from the sender
context = GetContext()
print("timestamp: ", timestamp)
Put(context, "timestamp", timestamp)
print("deposited")
return True
return False
def DepositNeo():
# get reference to the tx the invocation is in
tx = GetScriptContainer()
references = tx.References
if len(references) < 1:
print("no neo attached")
return False
# we need to determine who sent the tx
reference = references[0]
sender = GetScriptHash(reference)
# this will keep track of how much neo was deposited
value = 0
# this is the contract's address
receiver = GetExecutingScriptHash()
# go through all the outputs
# and check if the receiver is the contract
# if that is true, we add the value of the output to the
# total sum that was deposited
for output in tx.Outputs:
shash = GetScriptHash(output)
if shash == receiver:
output_asset_id = GetAssetId(output)
if output_asset_id == NEO_ASSET_ID:
output_val = GetValue(output)
value = value + output_val
if value > 0:
# now we know value was deposited from the sender
# check the current balance of the sender
# add it to the deposit amount, and save
context = GetContext()
current_balance = Get(context, sender)
new_balance = current_balance + value
Put(context, sender, new_balance)
# send deposit event
onDeposit(sender, value)
return True
return False
def spend(context, amount, src, dest, tag):
context = GetContext()
org_tag = concat(src, tag)
total = Get(context, org_tag)
if not total:
return False
if amount > total:
return False
Delete(context, org_tag)
new_total = total - amount
Put(context, org_tag, new_total)
receiver = GetExecutingScriptHash()
OnSpend(dest, amount, receiver)
return True
def PickWinner():
tx = GetScriptContainer()
context = GetContext()
references = tx.References
if _TimeHasExpired():
winningEntry = _getWinner()
schash = GetExecutingScriptHash()
entries = GetEntries()
numEntries = len(entries)
luckycut = numEntries - 30
OnWinner(winningEntry, luckycut, schash)
SetTime()
Put(context, "entries", 0)
else:
print("contest isn't over yet!")
def Register(prediction_name, context):
if CheckPredictionGameLive(prediction_name, context):
tx = GetScriptContainer()
refs = tx.References
if len(refs) < 1:
Log("No payment sent in transaction")
return False
ref = refs[0]
sentAsset = GetAssetId(ref)
sender_hash = GetScriptHash(ref)
k1 = concat("balance", sender_hash)
key = concat(k1, prediction_name)
balance = Get(context, key)
if balance >= 5:
Log("Already registered")
return False
else:
if sentAsset == GAS_ASSET_ID:
receiver = GetExecutingScriptHash()
totalGasSent = 0
cOutputs = len(tx.Outputs)
Log(cOutputs)
for output in tx.Outputs:
Log(output.Value)
shash = GetScriptHash(output)
if shash == receiver:
totalGasSent = totalGasSent + output.Value
Log("Total GAS sent:")
Log(totalGasSent)
if totalGasSent == b'\x00e\xcd\x1d':
Log("Correct GAS Received")
Put(context, key, 5)
return True
else:
Log("Wrong amount of GAS")
return False
else:
Log("Not GAS")
return False
else:
Log("Prediction Game not live")
return False
def Main(num):
receiver = GetExecutingScriptHash()
tx = GetScriptContainer()
references = tx.References
reference = references[0]
sender = GetScriptHash(reference)
output_asset_id = GetAssetId(reference)
if output_asset_id == GAS_ASSET_ID:
print("good")
for output in tx.Outputs:
shash = GetScriptHash(output)
value = GetValue(output) / 100000000
remainder = value % 1
value = value - remainder
OnSpend(b'AFxLPTwPoxowEHvvYYd5RKfJ3VqMTwh4pm', value, receiver)
return num
return 0
def Main(operation, args):
trigger = GetTrigger()
if trigger == Verification():
return CheckWitness(OWNER)
elif trigger == Application():
context = GetContext()
l = len(args)
if l == 1:
key = args[0]
elif l == 2:
key = args[0]
value = args[1]
else:
Log("Bad invocation argument count")
Log(l)
return False
if operation == 'getvalue':
return Get(context, key)
elif operation == 'putvalue':
prefix = take(key, 6)
if BADPREFIX == prefix:
Log("Hacking attempt!")
return False
if CheckWitness(OWNER):
Log("Owner found, bypassing payment")
Put(context, key, value)
return True
else:
# check if we got paid
tx = GetScriptContainer()
refs = tx.References
if len(refs) < 1:
Log("No payment sent in transaction")
return False
ref = refs[0]
sentAsset = GetAssetId(ref)
if sentAsset == GAS_ASSET_ID:
sender = GetScriptHash(ref)
receiver = GetExecutingScriptHash();
totalGasSent = 0
for output in tx.Outputs:
shash = GetScriptHash(output)
if shash == receiver:
totalGasSent = totalGasSent + output.Value
Log ("Total GAS sent:")
Log (totalGasSent)
pkey = concat('price/', key)
keyprice = Get(context, pkey)
if totalGasSent == keyprice:
Log("Price met, setting value and sending notification")
notification=[sender,key,value]
Notify(notification)
Put(context, key, value)
return True
Log("Price not met!")
return False
return False
elif operation == 'getprice':
key = concat('price/', key)
return Get(context, key)
elif operation == 'putprice':
if CheckWitness(OWNER):
key = concat('price/', key)
Put(context, key, value)
return True
else:
Log("Access denied")
return False
else:
Log("Invalid operation")
return False
return False
def Main(operation_string_para, args):
trigger = GetTrigger()
if trigger == Verification:
# all the hashes, which were found in the transaction outputs
script_hashes = getOutputScriptHashes()
if not script_hashes:
return False
withdrawal_controller = WithdrawalController()
for script_hash in script_hashes:
# these are all the assets, which were created by requesting withdrawals
released_assets = withdrawal_controller.getReleasedAssets(
script_hash)
if released_assets:
attachment = getAttachedAssets(script_hash)
# if the requestes asset value is not higher than the stored asset value, allow withdrawal
if attachment.gas_attached <= released_assets:
SpentReleasedAssets(script_hash, attachment.gas_attached)
return True
else:
n = 0
return False
elif trigger == Application:
if operation_string_para != None:
args_count = len(args)
if args_count < 1:
return 'error: please provide operation arguments'
# the operation controller check for arguments count and operation string matches
operations_controller = OperationsController()
# the withdrawal controller is reponsible for handling the withdrawal requests from the contracts receiver
withdrawal_controller = WithdrawalController()
init_operation_strings = operations_controller.validInitOperationStrings(
)
# after the receiver has transferred assets from the smart contract, the amount of his released assets has to be reduced.
if operations_controller.isSpentAssets(operation_string_para):
if not operations_controller.operationArgsAreValid(
operation_string_para, args):
return 'error: operation arguments count invalid'
address = args[0]
spent_assets = args[1]
return withdrawal_controller.spentAssets(address, spent_assets)
# the uid is the identifier for every payment contract between two partys
uid = args[0]
payment = Payment()
payment_in_use = payment.isInUse(uid)
# only handle init operations at this point
for init_operation_string in init_operation_strings:
if operation_string_para == init_operation_string:
if not operations_controller.operationArgsAreValid(
operation_string_para, args):
return 'error: operation arguments count invalid'
if payment_in_use:
return 'error: cant initialize payment contract. uid is in use'
principal = args[1]
receiver = args[2]
withdrawal_controller.initialize(uid, receiver)
if operations_controller.isInitTimeContract(
operation_string_para):
return payment.initializeTimeContract(args)
if operations_controller.isInitUnitsContract(
operation_string_para):
return payment.initializeUnitsContract(args)
# all remaining operations need an initialized payment contract
if not payment_in_use:
return 'error: operation invalid. payment contract not in use'
if not operations_controller.operationArgsAreValid(
operation_string_para, args):
return 'error: operation arguments count invalid'
payment_has_started = payment.hasStarted(uid)
if not payment_has_started:
return 'error: operation invalid. payment contract not in use yet'
# the balance is the available amount, minus spent units and those, which are currently
if operations_controller.isGetBalance(operation_string_para):
return payment.getBalance(uid)
principal = payment.getPrincipalAddress(uid)
receiver = payment.getReceiverAddress(uid)
is_principal = CheckWitness(principal)
is_receiver = CheckWitness(receiver)
# only the receiver can claim units, which he worked for in a UnitsContract
if operations_controller.isClaimUnits(operation_string_para):
if not is_receiver:
return 'error: not authorized'
units_to_claim = args[1]
units_to_claim = payment.claimUnits(uid, units_to_claim)
if units_to_claim:
OnClaimUnits(uid, units_to_claim)
return units_to_claim
# only the owner can authorized units, which the receiver claimed
if operations_controller.isAuthorizeUnits(operation_string_para):
if not is_principal:
return "error: not authorized"
units_to_authorize = args[1]
return payment.authorizeOpenUnits(uid, units_to_authorize)
# this will return the total amount of available assets transferred by withdrawal requests
# the receiver can use this, to get the amount of assets he can spent from the smart-contract
if operations_controller.isGetAvailableAssets(
operation_string_para):
if is_receiver:
return withdrawal_controller.getReleasedAssets(receiver)
return False
# this will return the amount of assets, which the receiver has requested
# the owner can use this, to deposit assets for the receiver
if operations_controller.isGetOpenWithdrawalValue(
operation_string_para):
if not is_principal:
return "error: not authorized"
return withdrawal_controller.getOpenWithdrawalValue(uid)
payment_type = payment.getType(uid)
# only the receiver can request withdrawals from the smart-contract
if operations_controller.isRequestWithdrawal(
operation_string_para):
if not is_receiver:
return "error: not authorized"
existing_withdrawal_request = withdrawal_controller.getWithdrawalRequest(
uid)
if existing_withdrawal_request:
return 'error: withdrawal request in progress. please wait until it finishes'
units_balance = payment.getUnitsBalance(uid)
if units_balance == 0:
return 'error: withdrawal request invalid. nothing to withdraw'
current_value = payment.getBalance(uid)
# if this payment contract was created with all assets deposited up front, there is no need to trigger an event.
# The withdrawal amount is released immediately
if payment_type == payment.PAYMENT_TYPE_UP_FRONT:
payment.spentUnitsAfterWithdrawalAuthorize(
uid, current_value, False)
withdrawal_controller.releaseAttachedAssets(
receiver, current_value)
return current_value
# all the assets for a withdrawal requests within a just-in-time contract need to deposited manually by the owner
elif payment_type == payment.PAYMENT_TYPE_JUST_IN_TIME:
withdrawal_controller.createNewWithdrawalRequest(
uid, units_balance, current_value)
payment.reserveUnitsForWithdrawal(uid, units_balance)
OnWithdrawalRequest(uid, current_value)
return current_value
return False
# this operation is used by the owner to deposit assets for the requested amount
if operations_controller.isDepositWithdrawalsRequest(
operation_string_para):
if not is_principal:
return "error: not authorized"
if payment_type == payment.PAYMENT_TYPE_UP_FRONT:
Notify(
'error: you cant deposit assets for an up-front contract'
)
return False
existing_withdrawal_request = withdrawal_controller.getWithdrawalRequest(
uid)
if not existing_withdrawal_request:
return 'error: there is no pending withdrawal request'
# we get all the assets, which are attached and are ment for the smart-contracts script hash
contract_script_hash = GetExecutingScriptHash()
attached_assets = getAttachedAssets(contract_script_hash)
attached_gas = attached_assets.gas_attached
if attached_gas == 0:
return 'error: no gas attached'
open_withdrawal_value = withdrawal_controller.getOpenWithdrawalValue(
uid)
# One can never deposit more assets than the requested amount
if attached_gas != open_withdrawal_value:
return 'error: attached gas amount has to match withdrawal requests value'
payment.spentUnitsAfterWithdrawalAuthorize(
uid, attached_gas, True)
withdrawal_controller.releaseAttachedAssets(
receiver, attached_gas)
withdrawal_controller.clearWithdrawalRequest(uid)
return attached_gas
return 'error: no operation string provided'
return 'error: unknown triger'
def initialize(self, args, consume_type):
if not consume_type:
return "error: no consume type defined"
uid = args[0]
principal_address = args[1]
receiver_address = args[2]
overall_value = args[3]
from_timestamp = args[4]
to_timestamp = args[5]
payment_type = args[6]
storage_api = StorageApi()
overall_value = overall_value * FACTOR
# when initializing an up-front contract, the total asset amount has to be attached
if payment_type == self.PAYMENT_TYPE_UP_FRONT:
contract_script_hash = GetExecutingScriptHash()
attached_assets = getAttachedAssets(contract_script_hash)
if attached_assets.gas_attached == 0:
return 'error: no gas attached'
if attached_assets.gas_attached != overall_value:
return 'error: attached gas is not matching overall value'
storage_api.putValue(self.STORAGE_KEY_UP_FRONT_HOLDINGS, uid,
attached_assets.gas_attached)
storage_api.putValue(self.STORAGE_KEY_PRINCIPAL_ADDRESS, uid,
principal_address)
storage_api.putValue(self.STORAGE_KEY_RECEIVER_ADDRESS, uid,
receiver_address)
storage_api.putValue(self.STORAGE_KEY_OVERALL_VALUE, uid,
overall_value)
storage_api.putValue(self.STORAGE_KEY_FROM_TIMESTAMP, uid,
from_timestamp)
storage_api.putValue(self.STORAGE_KEY_TO_TIMESTAMP, uid, to_timestamp)
storage_api.putValue(self.STORAGE_KEY_PAYMENT_TYPE, uid, payment_type)
storage_api.putValue(self.STORAGE_KEY_SPENT_UNITS, uid, 0)
storage_api.putValue(self.STORAGE_KEY_OPEN_UNITS, uid, 0)
storage_api.putValue(self.STORAGE_KEY_RESERVED_UNITS, uid, 0)
storage_api.putValue(self.STORAGE_KEY_CURRENT_UNITS, uid, 0)
storage_api.putValue(self.STORAGE_KEY_CONSUME_TYPE, uid, consume_type)
# for TimeContracts the total unit count is defined by the timestamps
if consume_type == self.CONSUME_TYPE_TIME:
total_units = to_timestamp - from_timestamp
storage_api.putValue(self.STORAGE_KEY_TOTAL_UNITS, uid,
total_units)
return True
# for UnitContracts the total unit count is set by the invoker
elif consume_type == self.CONSUME_TYPE_UNITS:
total_units = args[7]
storage_api.putValue(self.STORAGE_KEY_TOTAL_UNITS, uid,
total_units)
return True
else:
return False
return True
def Deposit(escrow_script_hash, note):
"""
Put money into the contract and set the transactions vins to be owned by escrow_script_hash
:param escrow_script_hash: the script hash who will be able to move these funds out
:type escrow_script_hash: bytearray
:param note: a note for the recipient (escrow_script_hash)
:type note: strung
:return: True if the deposit was successful, otherwise, false.
:rtype: bool
"""
# Get the transaction info.
tx = GetScriptContainer()
# Check if the transactions has currency attached
references = tx.References
if len(references) < 1:
return False
# Sender's script hash. We'll also grant them ownership of the funds if they need to retrieve their money
# before it's claimed or if it will never be claimed.
reference = references[0]
sender = GetScriptHash(reference)
# This is the contract's address
contract_script_hash = GetExecutingScriptHash()
context = GetContext()
deposited = False
# Go through all the outputs and handle deposits
for output in tx.Outputs:
shash = GetScriptHash(output)
output_asset_id = GetAssetId(output)
# We only care about NEO/GAS coming to the contract.
if shash == contract_script_hash:
output_val = GetValue(output)
deposited = True
# Update our total counter for this asset. This is just for fun display purposes
total_all_time_key = concat("totalAllTime", output_asset_id)
total_all_time = Get(context, total_all_time_key)
new_total_all_time = total_all_time + output_val
Put(context, total_all_time_key, new_total_all_time)
# Here we keep a record of all the tx hashes belonging to the sender and recipient.
# The idea is that they can view a list of these transactions.
#
# Also, the sender can rescind any that was still idle after a week (Mom didn't care enough to pick up
# her GAS)
if deposited:
tx_hash = GetHash(tx)
time = GetCurrentTimestamp()
tx_info = [escrow_script_hash, sender, time, note]
tx_info_serialized = serialize_array(tx_info)
Put(context, tx_hash, tx_info_serialized)
AddTransactionToScriptHash('recipient_history', escrow_script_hash,
tx_hash)
AddTransactionToScriptHash('sender_history', sender, tx_hash)
return True
return False
def CanWithdrawNeo():
print("[can withdraw]")
tx = GetScriptContainer()
type = GetType(tx)
invoke_type = b'\xd1'
print("[can withdraw] got tx type...")
if type == invoke_type:
print("[can withdraw] Is invocation!!")
# this is the contract's address
sender_addr = GetExecutingScriptHash()
withdrawal_amount = 0
receiver_addr = bytearray(0)
# go through the outputs of the tx
# and find ones that are neo
# and also the receiver cannot be the contract ( sender_addr )
for output in tx.Outputs:
shash = GetScriptHash(output)
output_asset_id = GetAssetId(output)
if output_asset_id == NEO_ASSET_ID:
output_val = GetValue(output)
if shash != sender_addr:
print("[can withdraw] output is to receiver")
receiver_addr = shash
withdrawal_amount = withdrawal_amount + output_val
Notify(withdrawal_amount)
Notify(output)
else:
print(
"[can withdraw] output is to contract sender addr, subtract from withdraw total"
)
withdrawal_amount = withdrawal_amount - output_val
Notify(output)
else:
print("[can withdraw] output is not neo")
Notify(output)
# we check recevier addr and amount
if len(receiver_addr) > 0:
print("[can withdraw] receiver addr is valid")
Notify(receiver_addr)
context = GetContext()
current_balance = Get(context, receiver_addr)
print("[can withdraw] current balance")
Notify(current_balance)
Notify(withdrawal_amount)
if withdrawal_amount <= current_balance:
print("[can withdraw] withdrawl amount il less than balance")
onWithdraw(receiver_addr, withdrawal_amount)
return True
else:
print("[can withdraw] not enough to witdraw")
else:
print("[can withdraw] receiver addr not set")
else:
print("[can withdraw] tx is not invocation tx. return false")
return False
def Main(operation, args):
"""
:param operation: get or put
:param args: optional arguments
:return: Bool
"""
Log("Running Main Loop")
trigger = GetTrigger()
if trigger == Verification:
Log("trigger: Verification")
is_owner = CheckWitness(owner)
if is_owner:
return True
elif trigger == Application:
Log("trigger: Application")
context = GetContext()
if operation == 'getvalue':
Log("op: getvalue")
key = args[0]
return Get(context, key)
if operation == 'register-oracle':
Log("op: register-oracle")
nArgs = len(args)
Log(nArgs)
if len(args) != 1:
return False
tx = GetScriptContainer()
refs = tx.References
if len(refs) < 1:
Log("No payment sent in transaction")
return False
ref = refs[0]
sentAsset = GetAssetId(ref)
sender = GetScriptHash(ref)
oracle_app = args[0]
k = concat(sender, oracle_app)
amount = Get(context, k)
if amount == 5:
Log("Already registered")
return False
if sentAsset == GAS_ASSET_ID:
Log("Ok it is GAS")
receiver = GetExecutingScriptHash()
totalGasSent = 0
cOutputs = len(tx.Outputs)
Log(cOutputs)
for output in tx.Outputs:
Log(output.Value)
shash = GetScriptHash(output)
if shash == receiver:
totalGasSent = totalGasSent + output.Value
Log("Total GAS sent:")
Log(totalGasSent)
if totalGasSent == b'\x00e\xcd\x1d':
Log("That's what we wanted")
Notify("We received the GAS")
Put(context, k, 5)
return True
else:
Log("We didn't want this.")
return False
else:
Log("Not Gas")
return False
return False
def AddEntry():
tx = GetScriptContainer()
context = GetContext()
references = tx.References
if _TimeHasExpired():
# refund gas and neo and pick winner
PickWinner()
return 0
print("adding entry")
if len(references) < 1:
print("no gas attached")
return False
print("reading reference")
reference = references[0]
print("reference read")
sender = GetScriptHash(reference)
print("sender hash is")
print(sender)
print("reading script hash")
print("getting asset ID. ID is here:")
output_asset_id = GetAssetId(reference)
print(output_asset_id)
print('asset id printed above')
if output_asset_id == GAS_ASSET_ID:
print("executing script hash")
receiver = GetExecutingScriptHash()
for output in tx.Outputs:
shash = GetScriptHash(output)
print("getting shash..")
if shash == receiver:
print("adding value?")
value = GetValue(output) / 100000000
print("value storing in entries")
print(value)
print('string we will save to the entries array')
entries = Get(context, 'entries')
print('current entries')
print(entries)
remainder = value % 1
print('remainder is')
Notify(remainder)
value = value - remainder
print('remainder and value set')
Notify(value)
if value > 0:
if entries != bytearray(b''):
print('deserializing the byte array')
entries = deserialize_bytearray(entries)
end = len(entries) + value
if end > 1024:
print('contest capped at 1024')
return 0
new_entries = range(0, end)
i = 0
for item in new_entries:
if i < len(entries):
new_entries[i] = entries[i]
else:
new_entries[i] = sender
i += 1
# last_entry = entries[len(entries) - 1]
# colon_index = [pos for pos, char in enumerate(
# last_entry) if char == ':']
# previous_total = substr(
# last_entry, 0, colon_index)
else:
print('setting an empty array')
# list isn't working below
new_entries = range(0, value)
j = 0
for item in new_entries:
new_entries[j] = sender
j += 1
else:
print("no gas added")
Notify(new_entries)
new_entries = serialize_array(new_entries)
Put(context, "entries", new_entries)
return entries
def MintTokens():
"""
Method for an address to call in order to deposit NEO into the NEP5 token owner's address in exchange for a calculated amount of NEP5 tokens
:return: whether the token minting was successful
:rtype: bool
"""
print("minting tokens!")
tx = GetScriptContainer()
references = tx.References
print("helol1")
if len(references) < 1:
print("no neo attached")
return False
print("hello2")
reference = references[0]
print("hello2")
# sender = reference.ScriptHash
sender = GetScriptHash(reference)
print("hello4")
value = 0
print("hello5")
output_asset_id = GetAssetId(reference)
if output_asset_id == NEO_ASSET_ID:
print("hello6")
receiver = GetExecutingScriptHash()
print("hello7")
for output in tx.Outputs:
shash = GetScriptHash(output)
print("getting shash..")
if shash == receiver:
print("adding value?")
output_val = GetValue(output)
value = value + output_val
print("getting rate")
rate = CurrentSwapRate()
print("got rate")
if rate == 0:
OnRefund(sender, value)
return False
num_tokens = value * rate / 100000000
context = GetContext()
balance = Get(context, sender)
new_total = num_tokens + balance
Put(context, sender, new_total)
total_supply = Get(context, 'totalSupply')
new_total_supply = total_supply + num_tokens
Put(context, 'totalSupply', new_total_supply)
OnTransfer(0, sender, num_tokens)
return True
return False
def ReconcileBalances():
print("[Reconcile balances]")
# this is the contract's address
sender_addr = GetExecutingScriptHash()
tx = GetScriptContainer()
withdrawal_amount = 0
receiver_addr = bytearray(0)
# go through the outputs of the tx
# and find ones that are neo
# and also the receiver cannot be the contract ( sender_addr )
for output in tx.Outputs:
shash = GetScriptHash(output)
output_asset_id = GetAssetId(output)
if output_asset_id == NEO_ASSET_ID:
if shash != sender_addr:
print("[reconcile] output is to receiver")
receiver_addr = shash
output_val = GetValue(output)
withdrawal_amount = withdrawal_amount + output_val
Notify(withdrawal_amount)
Notify(output)
else:
print(
"[Reconcile balances] output is to contract sender addr, ignore"
)
Notify(output)
else:
print("[Reconcile balances] output is not neo")
Notify(output)
# we check recevier addr and amount
if len(receiver_addr) > 0:
print("[Reconcile balances] receiver addr is valid")
Notify(receiver_addr)
context = GetContext()
current_balance = Get(context, receiver_addr)
print("[Reconcile balances] current balance")
Notify(current_balance)
Notify(withdrawal_amount)
if withdrawal_amount <= current_balance:
new_balance = current_balance - withdrawal_amount
print("[Reconcile balances] new balance is...")
Notify(current_balance)
Notify(new_balance)
Put(context, receiver_addr, new_balance)
onWithdrawReconciled(receiver_addr, new_balance)
print("[Reconcile balances] withdrawl amount il less than balance")
return True
else:
print("[Reconcile balances] not enough to witdraw")
else:
print("[Reconcile balances] receiver addr not set")
return False
def CanWithdrawNeo():
print("[can withdraw]")
is_invocation = IsInvocationTx()
if is_invocation:
# this is the contract's address
sender_addr = GetExecutingScriptHash()
tx = GetScriptContainer()
withdrawal_amount = 0
receiver_addr = bytearray(0)
# go through the outputs of the tx
# and find ones that are neo
# and also the receiver cannot be the contract ( sender_addr )
for output in tx.Outputs:
shash = GetScriptHash(output)
output_asset_id = GetAssetId(output)
if output_asset_id == NEO_ASSET_ID:
if shash != sender_addr:
print("[can withdraw] output is to receiver")
receiver_addr = shash
output_val = GetValue(output)
withdrawal_amount = withdrawal_amount + output_val
Notify(withdrawal_amount)
Notify(output)
else:
print(
"[can withdraw] output is to contract sender addr, ignore"
)
Notify(output)
else:
print("[can withdraw] output is not neo")
Notify(output)
# we check recevier addr and amount
if len(receiver_addr) > 0:
print("[can withdraw] receiver addr is valid")
Notify(receiver_addr)
context = GetContext()
current_balance = Get(context, receiver_addr)
print("[can withdraw] current balance")
Notify(current_balance)
Notify(withdrawal_amount)
if withdrawal_amount <= current_balance:
print("[can withdraw] withdrawl amount il less than balance")
onWithdraw(receiver_addr, withdrawal_amount)
return True
else:
print("[can withdraw] not enough to witdraw")
else:
print("[can withdraw] receiver addr not set")
return False
def Main(operation, args):
trigger = GetTrigger()
if trigger == Verification():
# Verification is done when sending money out of the contract.
#
# We need to check the sender's balance to make sure they have enough to allow them
# to send what they're trying to send
#
# Note: Contract owner has no special privileges here.
tx = GetScriptContainer()
valid = False
# Go through all the outputs and make sure there's only one output destination.
# This will be used if we're auto-rescinding the assets (ie sending back to the original
# sender after a week goes by without the recipient picking up). We'll make sure there's only
# one output script hash and it matches the stored script hash of the original sender
#
# Also we make sure not outputs are going to the contract script hash because we don't support
# change.
output_script_hash = None
contract_script_hash = GetExecutingScriptHash()
for output in tx.Outputs:
shash = GetScriptHash(output)
if shash == contract_script_hash:
return False
if output_script_hash == None:
output_script_hash = shash
elif shash != output_script_hash:
return False
for input in tx.Inputs:
hash = InputGetHash(input)
context = GetContext()
tx_info_serialized = Get(context, hash)
tx_info = deserialize_bytearray(tx_info_serialized)
escrow = tx_info[0]
sender = tx_info[1]
time = tx_info[2]
is_escrow = CheckWitness(escrow)
if is_escrow != True:
if sender != output_script_hash:
return False
current_time = GetCurrentTimestamp()
seven_days = 604800
minimum_time = time + seven_days
if current_time < minimum_time:
return False
# We have at least one. We'll keep checking if there are more.
print('That input was valid')
valid = True
print('All good')
return valid
elif trigger == Application():
if operation == 'name':
n = "Sendeo"
return n
elif operation == 'deposit':
if len(args) != 2:
return False
recipient = args[0]
note = args[1]
deposit = Deposit(recipient, note)
return deposit
return False
def mint_tokens():
"""
Mint tokens during a crowdsale period.
:return:
bool: Whether tokens were successfully minted.
"""
attachments = Attachments()
context = GetContext()
# If the token is not deployed yet, return.
if not Get(context, token_deployed):
print("Call deploy_token before minting..")
return False
tx = GetScriptContainer() # type:Transaction
references = tx.References
attachments.receiver_addr = GetExecutingScriptHash()
if len(references) > 0:
reference = references[0]
attachments.sender_addr = reference.ScriptHash
sent_amount_neo = 0
sent_amount_gas = 0
for output in tx.Outputs:
if output.ScriptHash == attachments.receiver_addr and output.AssetId == attachments.neo_asset_id:
sent_amount_neo += output.Value
if output.ScriptHash == attachments.receiver_addr and output.AssetId == attachments.gas_asset_id:
sent_amount_gas += output.Value
attachments.neo_attached = sent_amount_neo
#attachments.gas_attached = sent_amount_gas
# Accepting NEO for the sale.
if attachments.neo_attached == 0:
return False
# The following looks up whether an address has been
# registered with the contract for KYC regulations
# this is not required for operation of the contract.
if not kyc_status(attachments.sender_addr):
return False
# Calculate the amount requested.
amount_requested = attachments.neo_attached * tokens_per_neo / 100000000
# Check if we can exchange.
can_exchange = calculate_can_exchange(amount_requested, attachments.sender_addr)
if not can_exchange:
return False
# Lookup the current balance of the address.
current_balance = Get(context, attachments.sender_addr)
# Calculate the amount of tokens the attached neo will earn.
exchanged_tokens = attachments.neo_attached * tokens_per_neo / 100000000
# If using GAS instead of NEO use this.
# exchanged_tokens += attachments.gas_attached * tokens_per_gas / 100000000
# Add it to the exchanged tokens and put it into storage.
new_total = exchanged_tokens + current_balance
Put(context, attachments.sender_addr, new_total)
# Update the circulation amount.
add_to_circulation(exchanged_tokens)
# Dispatch the transfer event.
OnTransfer(attachments.receiver_addr, attachments.sender_addr, exchanged_tokens)
return True
