def put(self, key, value):
Put(self.ctx, key, value)
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 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 Main(value):
Put("key", value)
def voteForOutcome(self, ID: bytes, outcome: int, amount: int,
voter: bytes, contractAddress: bytes):
ctx = GetContext()
#check if witness
isvoter = CheckWitness(voter)
if not isvoter:
#print('Must be voter to vote for outcome')
return False
#check if Oracle is challenged
isChallenged = self.isChallenged(ID)
if not isChallenged:
#print('Oracle is not be challenged yet')
return False
#check if front runner period is not over yet
isFrontRunnerPeriodOver = self.isFrontRunnerPeriodOver(ID)
if isFrontRunnerPeriodOver:
#print('Front runner period is over, oracle is done')
return False
#read param from storage
keySpreadMultiplier = concat(b'SpreadMultiplier', ID)
spreadMultiplier = Get(ctx, keySpreadMultiplier)
keyTotalAmount = concat(b'TotalAmount', ID)
totalAmount = Get(ctx, keyTotalAmount)
keyTotalOutcomeAmounts = concat(outcome, ID)
totalOutcomeAmounts = Get(ctx, keyTotalOutcomeAmounts)
maxAmount = (totalAmount - totalOutcomeAmounts) * spreadMultiplier
if maxAmount > totalOutcomeAmounts:
maxAmount = maxAmount - totalOutcomeAmounts
else:
maxAmount = 0
if amount > maxAmount:
amount = maxAmount
#deposit
isok = self.deposit(voter, contractAddress, amount)
if not isok:
#print('Deposit Failed')
return False
keyOutcomeAmountT = concat(voter, ID)
keyOutcomeAmount = concat(outcome, keyOutcomeAmountT)
outcomeAmount = Get(ctx, keyOutcomeAmount)
outcomeAmount = outcomeAmount + amount
Put(ctx, keyOutcomeAmount, outcomeAmount)
keyTotalOutcomeAmounts = concat(outcome, ID)
totalOutcomeAmounts = Get(ctx, keyTotalOutcomeAmounts)
totalOutcomeAmounts = totalOutcomeAmounts + amount
Put(ctx, keyTotalOutcomeAmounts, totalOutcomeAmounts)
keyTotalAmount = concat(b'TotalAmount', ID)
totalAmount = Get(ctx, keyTotalAmount)
totalAmount = totalAmount + amount
Put(ctx, keyTotalAmount, totalAmount)
#check if front runner changes
keyFrontRunner = concat(b'FrontRunner', ID)
frontRunner = Get(ctx, keyFrontRunner)
keyTotalOutcomeAmountsF = concat(frontRunner, ID)
totalOutcomeAmountsF = Get(ctx, keyTotalOutcomeAmountsF)
isfrontrunnerChanges1 = (outcome != frontRunner)
isfrontrunnerChanges2 = (totalOutcomeAmounts > totalOutcomeAmountsF)
if not isfrontrunnerChanges1:
return False
if not isfrontrunnerChanges2:
return False
else:
Put(ctx, keyFrontRunner, outcome)
now = self.now()
keyFrontRunnerSetTimestamp = concat(b'FrontRunnerSetTimestamp', ID)
Put(ctx, keyFrontRunnerSetTimestamp, now)
return True
def relic_price_write(context, owner, relic, price):
price_key = relic_price_key(owner, relic)
Put(context, price_key, price)
OnRelicPrice(owner, relic, price)
def Main(operation, args):
"""
Calling the Main function of this NEO smart contract enables registering
a last will or inheritage datum. It also allows to set heirs and transfers
of inheritage, which works exactly like the NEO licensing contracts.
"""
caller = args[0] # used with CheckWitness below to conform authorization
caller_is_authorized = CheckWitness(caller) # Boolean
if not caller_is_authorized:
print('Action denied.')
return False
print('Action granted.')
input_inheritage_datum = args[1]
caller_with_input_will_or_inheritage_datum = concat(caller, input_inheritage_datum)
# Set testator_or_heir to the optional third argument or use the caller
if len(args) == 3:
testator_or_heir = args[2]
legal_entity_with_inheritage_datum = concat(testator_or_heir, input_inheritage_datum)
else:
testator_or_heir = caller
legal_entity_with_inheritage_datum = caller_with_input_will_or_inheritage_datum
if operation != None:
if operation == 'RegisterWillOrInheritage':
"""
Register will or equity specification
document to the contract caller.
"""
storage_occupying_name = Get(GetContext, input_inheritage_datum)
if storage_occupying_name:
print(storage_occupying_name)
else:
Put(GetContext, input_inheritage_datum, caller)
print("Your will was successfully registered.")
return True
if operation == 'SetInheritage':
"""
Set a testator_or_heir for a registered equity.
"""
if authorization_check(input_inheritage_datum):
Put(GetContext, legal_entity_with_inheritage_datum, testator_or_heir)
print("The inheritage was successfully set to legal entity.")
return True
if operation == 'QueryInheritage':
"""
Quiery the legal testator_or_heir of an inheritage.
"""
legal_testator_or_heir = Get(GetContext, legal_entity_with_inheritage_datum)
print(legal_testator_or_heir)
if legal_testator_or_heir:
return True
if operation == 'CancelInheritage':
if authorization_check(input_inheritage_datum):
testator_or_heir_to_del = args[2]
inheritage_to_be_removed = concat(testator_or_heir_to_del, input_inheritage_datum)
Delete(GetContext, inheritage_to_be_removed)
print("The inheritance was successfully removed from the will.")
return True
if operation == 'ChangeInheritage':
legal_entity = Get(GetContext, caller_with_input_will_or_inheritage_datum)
if legal_entity:
is_authorized_legal_entity = CheckWitness(legal_entity)
if is_authorized_legal_entity:
changed_testator_or_heir = args[2]
changed_testator_with_input_inheritage_datum = concat(changed_testator_or_heir, input_inheritage_datum)
Delete(GetContext, caller_with_input_will_or_inheritage_datum)
Put(GetContext, changed_testator_with_input_inheritage_datum, changed_testator_or_heir)
print("Your will has changed.")
return True
return False
def put(category, id, value):
skey = concat(category, id)
Put(GetContext(), skey, value)
def AddOracle(prediction_name, normalised_timestamp, oracle, context):
k0 = concat("oracles", prediction_name)
key = concat(k0, normalised_timestamp)
oracles = Get(context, key)
new_oracles = concat(oracles, oracle)
Put(context, key, new_oracles)
def AddBalance(prediction_name, sender_hash, winnings, context):
k0 = concat("balance", sender_hash)
key = concat(k0, prediction_name)
balance = Get(context, key)
balance = balance + winnings
Put(context, key, balance)
def UpdateTimestamp(prediction_name, timestamp, context):
key = concat("timestamp", prediction_name)
Put(context, key, timestamp)
def UpdateMaxVotes(prediction_name, normalised_timestamp, count, context):
k0 = concat("max_votes", prediction_name)
key = concat(k0, normalised_timestamp)
Put(context, key, count)
def ZeroBalance(prediction_name, sender_hash, context):
k0 = concat("balance", sender_hash)
key = concat(k0, prediction_name)
Put(context, key, 0)
def put_offer(marketplace, address, item_id, price):
"""
Put a new offer up on a marketplace.
:return:
bool: Whether the offer was put.
"""
context = GetContext()
# The price of the offer must be greater than 0.
if price <= 0:
return False
# Check marketplace permissions.
owner = marketplace_owner(marketplace)
if not CheckWitness(owner):
print("Operation Forbidden: Only the owner of this marketplace may invoke the operation - put_offer")
return False
# If the removal of the item from the address was successful, put the offer up.
if remove_item(marketplace, address, item_id):
# Concatenate the key to get the current index of the marketplace, then get the current offer index.
marketplace_index_key = concat(current_offer_index_key, marketplace)
index = Get(context, marketplace_index_key)
# Concatenate the key to get all the offers on the marketplace.
marketplace_offers_key = concat(offers_key,marketplace)
# If the index has not been set yet we create it, else we create a new offer id with the current index.
if not index:
index = 1
marketplace_offer_id = concat(marketplace, "offer\x01")
else:
# Create the offer id to put into storage.
offer_id = concat("offer", index)
# Concatenate the name of the marketplace and offer so we can access these offers on individual markets.
marketplace_offer_id = concat(marketplace, offer_id)
# Get the list of all offers that are currently up in the marketplace.
all_offers_s = get_all_offers(marketplace)
# If there are no offers in the storage, put the first element in a new list
# else, append the offer id to the pre-existing list of offer ids.
if not all_offers_s:
all_offers = [marketplace_offer_id]
else:
all_offers = deserialize_bytearray(all_offers_s)
all_offers.append(marketplace_offer_id)
# Serialize the list of offers we have modified.
all_offers_s = serialize_array(all_offers)
# Create a new serialized offer ready to put into storage.
offer = new_offer(address, marketplace_offer_id, item_id, price)
# Put the list of all offers and the offer id into storage.
Delete(context, marketplace_offers_key)
Put(context, marketplace_offers_key, all_offers_s)
Put(context, marketplace_offer_id, offer)
# Can now increment the offer index for the marketplace and save it into storage.
index += 1
Delete(context, marketplace_index_key)
Put(context, marketplace_index_key, index)
return True
return False
def relic_balance_write(context, owner, relic, amount):
owner_key = relic_balance_key(owner, relic)
Put(context, owner_key, amount)
OnRelicBalance(owner, relic, amount)
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
def relic_sell_write(context, owner, relic, amount):
sale_key = relic_sale_key(owner, relic)
Put(context, sale_key, amount)
OnRelicSell(owner, relic, amount)
def Milestone(milestone_key, agreement, customer, assignee, platform,
timestamp, utc_offset, oracle, pay_out, asset, threshold):
"""
Method to create a milestone
:param milestone_key: unique identifier for the milestone
:type milestone_key: str
:param agreement: key of the parent agreement this milestone belongs to
:type agreement: str
:param customer: customer party of the milestone
:type customer: bytearray
:param assignee: assignee party of the milestone
:type assignee: bytearray
:platform: id of platform on which the project repository is (e.g. GitHub)
:type platform: str
:param timestamp: timezone naive datetime of the day of the event
:type timestamp: int
:param utc_offset: positive or negative utc_offset for timestamp
:type utc_offset: int
:param oracle: oracle (reviewer of the task)
:type oracle: bytearray
:param pay_out: the amount to pay out to the assignee on success
:type pay_out: int
:param asset: the NEO asset used in the milestone instance
type asset: bytearray
:param threshold: the minimum score for the milestone (out of 100)
:type threshold: int
:return: whether the milestone was successfully added
:rtype: bool
"""
context = GetContext()
m = Get(context, milestone_key)
if len(m) > 0:
Notify("milestone_key not unique, please use another")
return False
# Get timestamp of current block
currentHeight = GetHeight()
currentBlock = GetHeader(currentHeight)
current_time = currentBlock.Timestamp
# Compute timezone adjusted time
timezone_timestamp = timestamp + (utc_offset * 3600)
timezone_current_time = current_time + (utc_offset * 3600)
# Check if timestamp is not out of boundaries
if timezone_timestamp < (timezone_current_time + MIN_TIME - TIME_MARGIN):
Notify("Datetime must be $MIN_TIME seconds ahead")
return False
elif timezone_timestamp > (timezone_current_time + MAX_TIME + TIME_MARGIN):
Notify("Datetime must be $MAX_TIME seconds ahead")
return False
fee = Get(context, 'fee')
if len(fee) == 0:
fee = INITIAL_FEE
# Check if pay_out and fee are not zero or below
if pay_out <= 0:
Notify("Pay_out is zero or negative")
return False
if fee <= 0:
Notify("Fee is zero or negative")
return False
# check if payment is received if milestone is not created by OWNER
if not CheckWitness(OWNER):
attachments = get_asset_attachments()
total_cost = pay_out + fee
if asset == attachments.neo_asset_id:
if attachments.neo_attached > 0:
if not attachments.neo_attached == total_cost:
Notify("Incorrect payment received, returning funds")
DoTransfer(OWNER, customer, attachments.neo_attached)
return False
else:
Notify("No payment received")
return False
elif asset == attachments.gas_asset_id:
if attachments.gas_attached > 0:
if not attachments.gas_attached == total_cost:
Notify("Incorrect payment received, returning funds")
DoTransfer(OWNER, customer, attachments.gas_attached)
return False
else:
Notify("No payment received")
return False
status = 'initialized'
# Set place holder value
review_score = 0
milestone_data = [agreement, customer, assignee, platform, timestamp, utc_offset, oracle, pay_out, asset, fee, threshold, status, review_score]
milestone_data_serialized = serialize_array(milestone_data)
Put(context, milestone_key, milestone_data_serialized)
DispatchMilestoneEvent(milestone_key)
return True
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
