def do_approve(ctx, t_owner, t_spender, amount): if len(t_spender) != 20: return False if not CheckWitness(t_owner): return False if amount < 0: return False # Token owner logic to not touch the team funding and the company reserve # When making transfers from_balance = Get(ctx, t_owner) if CheckWitness(TOKEN_OWNER): team_reserve = Get(ctx, TEAM_RESERVE_KEY) company_reserve = Get(ctx, COMPANY_RESERVE_KEY) from_balance = from_balance - team_reserve from_balance = from_balance - company_reserve if from_balance >= amount: approval_key = concat(t_owner, t_spender) if amount == 0: Delete(ctx, approval_key) else: Put(ctx, approval_key, amount) OnApprove(t_owner, t_spender, amount) return True return False
def kyc_register(ctx, args): """ Register a list of addresses for KYC :param ctx:GetContext() used to access contract storage :param args:list a list of addresses to register. If called by KYC admin that is not token owner, first address must be address of KYC admin. :return:int The number of addresses registered for KYC """ ok_count = 0 canRegister = CheckWitness(TOKEN_OWNER) if not canRegister and get_kyc_admin_status(ctx, args[0]) and CheckWitness( args[0]): canRegister = True args.remove(0) if canRegister: for address in args: # validate the address is 20 bytes if len(address) == 20: Put(ctx, concat(KYC_KEY, address), True) OnKYCRegister(address) ok_count += 1 return ok_count
def kyc_deregister(ctx, args): """ Deregister a list of addresses from KYC :param ctx:GetContext() used to access contract storage :param args:list a list of addresses to deregister :return:int The number of addresses deregistered from KYC """ ok_count = 0 canRegister = CheckWitness(TOKEN_OWNER) if not canRegister and get_kyc_admin_status(ctx, args[0]) and CheckWitness( args[0]): canRegister = True args.remove(0) if canRegister: for address in args: if len(address) == 20: Delete(ctx, concat(KYC_KEY, address)) OnKycDeregister(address) ok_count += 1 return ok_count
def Main(operation, args): trigger = GetTrigger() if trigger == Verification(): is_owner = CheckWitness(CONTRACT_OWNER) if is_owner: return True else: return False elif trigger == Application(): sender = args[0] authorized = CheckWitness(sender) """ Make sure that invoker is valid """ if not authorized: Notify("Not authorized") return False Log("test") Notify(len(args)) """ query operations """ if operation == "sendMessage" and len(args) == 4: Notify("In operation sendMessage") return sendMessage(args) else: return False return False
def company_approve(ctx, t_owner, t_spender): if not CheckWitness(TOKEN_OWNER): print("Must be token owner to approve funds") return False if len(t_spender) != 20: return False if not CheckWitness(t_owner): return False company_reserv_amount = Get(ctx, COMPANY_RESERVE_KEY) if company_reserv_amount <= 0: return False if Get(ctx, t_owner) >= amount: approval_first_part = concat(t_owner, t_spender) approval_key = concat(approval_first_part, MONTH_KEY) height = GetHeight() deposit_address_key = concat(approval_key, deposit_key) Put(ctx, deposit_address_key, height) Put(ctx, approval_key, MONTHLY_ALLOWANCE) OnApprove(t_owner, t_spender, MONTHLY_ALLOWANCE) return True return False
def Main(operation, args): """ Main definition for the smart contracts :param operation: the operation to be performed :type operation: str :param args: list of arguments. args[0] is always sender script hash args[1] is always domain args[2] (optional) is either target or other address args[3] (optional) is target (if args[2] is address) :param type: str :return: byterarray: The result of the operation """ # Common definitions user_hash = args[0] domain = args[1] domain_owner_key = concat(domain, ".owner") domain_target_key = concat(domain, ".target") owner = b'#\xba\'\x03\xc52c\xe8\xd6\xe5"\xdc2 39\xdc\xd8\xee\xe9' # This doesn't require authentication if operation == 'GetDomain': return Get(GetContext(), domain_target_key) # Everything after this requires authorization authorized = CheckWitness(user_hash) if not authorized: Log("Not Authorized") return False Log("Authorized") if operation == 'RegisterDomain': if (CheckWitness(owner)): address = args[2] Put(GetContext(), domain_owner_key, address) if len(args) == 4: target = args[3] Put(GetContext(), domain_target_key, target) return True if operation == 'SetDomainTarget': domain_owner = Get(GetContext(), domain_owner_key) if (CheckWitness(domain_owner)) or (CheckWitness(owner)): # License the product target = args[2] Put(GetContext(), domain_target_key, target) return True if operation == 'DeleteDomain': if (CheckWitness(owner)): Delete(GetContext(), domain_owner_key) Delete(GetContext(), domain_target_key) return True return False
def do_transfer(ctx, t_from, t_to, amount): if amount <= 0: return False if len(t_to) != 20: return False if CheckWitness(t_from): if t_from == t_to: print("transfer to self!") return True from_val = Get(ctx, t_from) if CheckWitness(TOKEN_OWNER): team_reserve = Get(ctx, TEAM_RESERVE_KEY) company_reserve = Get(ctx, COMPANY_RESERVE_KEY) from_val = from_val - team_reserve from_val = from_val - company_reserve if from_val < amount: print("insufficient funds") return False difference = from_val - amount difference = difference + company_reserve difference = difference + team_reserve if difference == 0: Delete(ctx, t_from) else: Put(ctx, t_from, difference) else: if from_val < amount: print("insufficient funds") return False difference = from_val - amount if from_val == amount: Delete(ctx, t_from) else: Put(ctx, t_from, difference) to_value = Get(ctx, t_to) to_total = to_value + amount Put(ctx, t_to, to_total) OnTransfer(t_from, t_to, amount) return True else: print("from address is not the tx sender") return False
def Main(operation, args): trigger = GetTrigger() if trigger == Verification(): if CheckWitness(OWNER): return True return False elif trigger == Application(): if operation == 'hello': print('hello world!') totalcalls = Get('totalCalls') totalcalls = totalcalls + 1 print(totalcalls) if Put('totalCalls', totalcalls): return True print('staked storage call failed') return False return True if operation == 'ownerWithdraw': if not CheckWitness(OWNER): print( 'only the contract owner can withdraw MCT from the contract' ) return False if len(args) != 1: print('withdraw amount not specified') return False t_amount = args[0] myhash = GetExecutingScriptHash() return MCTContract('transfer', [myhash, OWNER, t_amount]) # end of normal invocations, reject any non-MCT invocations caller = GetCallingScriptHash() if caller != MCT_SCRIPTHASH: print('token type not accepted by this contract') return False if operation == 'onTokenTransfer': print('onTokenTransfer() called') return handle_token_received(caller, args) return False
def make_offer(offer) -> bool: ''' Make New Offer on books :param offer: :return: Result of if offer was valid ''' if not CheckWitness(offer.MakerAddress): return False # Checking that the person that invoked this was the smart contract it self if not CheckWitness(OWNER): return False allowed = get_state() if allowed == 'Inactive' or allowed == 'Pending': return False if (allowed == 'Terminated' and not offer.OfferAssetID == NeoAssetID and offer.WantAssetID == GasAssetID and not offer.WantAssetID == NeoAssetID and offer.OfferAssetID == GasAssetID): return False trading_pair = offer.OfferAssetID + offer.WantAssetID offer_hash = hash(offer) storage = MCTManager() if storage.get(trading_pair + offer_hash): return False if not offer.OfferAmount > 0 and offer.WantAmount > 0: return False if offer.OfferAssetID == offer.WantAssetID: return False if (len(offer.OfferAssetID) != 20 and len(offer.OfferAssetID) != 32 or len(offer.WantAssetID) != 20 and len(offer.WantAssetID) != 32): return False if not reduce_balance(offer.MakerAddress, offer.OfferAssetID, offer.OfferAmount): return False store_offer(trading_pair, offer_hash, offer) created(offer.MakerAddress, offer_hash, offer.OfferAssetID, offer.OfferAmount, offer.WantAssetID, offer.WantAmount) return True
def make_offer(offer): ''' Make New Offer on books :param offer: :return: Result of if offer was valid ''' if not CheckWitness(offer["MakerAddress"]): return False # Checking that the person that invoked this was the smart contract it self if not CheckWitness(OWNER): return False allowed = get("state") if allowed == 'Inactive' or allowed == 'Pending': return False if (allowed == 'Terminated' and not offer["OfferAssetID"] == NeoAssetID and offer["WantAssetID"] == GasAssetID and not offer["WantAssetID"] == NeoAssetID and offer["OfferAssetID"] == GasAssetID): return False trading_pair = offer["OfferAssetID"] + offer["WantAssetID"] offer_hash = serialize_array(offer) if get(trading_pair + offer_hash): return False if not offer["OfferAmount"] > 0 and offer["WantAmount"] > 0: return False if offer["OfferAssetID"] == offer["WantAssetID"]: return False if (len(offer["OfferAssetID"]) != 20 and len(offer["OfferAssetID"]) != 32 or len(offer["WantAssetID"]) != 20 and len(offer["WantAssetID"]) != 32): return False if not reduce_balance(offer["MakerAddress"], offer["OfferAssetID"], offer["OfferAmount"]): return False store_offer(trading_pair, offer_hash, offer) created(offer["MakerAddress"], offer_hash, offer["OfferAssetID"], offer["OfferAmount"], offer["WantAssetID"], offer["WantAmount"]) return True
def WithdrawFunds(args): sender = args[0] amount = args[1] if not CheckWitness(sender): print('Account owner must be sender') return [False, 'Account owner must be sender'] if amount < 0: print('Must withdraw positive amount') return [False, 'Must withdraw positive amount'] user_funds = GetUserFunds(args) funds = user_funds[1] if amount > funds: print('Not enough funds for desired amount') return [False, 'Not enough funds'] context = GetContext() _ = AddFunds(context, sender, -amount) # Error if we don't define 'return' value OnWithdraw(sender, amount) return [True, '']
def DeletePublication(args): sender = args[0] name = args[1] if not CheckWitness(sender): print('Account owner must be sender') return [False, 'Account owner must be sender'] context = GetContext() publications_key = concat('publications', sender) publication_key = concat(publications_key, sha1(name)) publication = Get(context, publication_key) if not publication: print('Publication does not exist') return [False, 'Publication does not exist'] publication = Deserialize(publication) if not publication[5]: print('Publication has already been deleted') return [False, 'Publication has already been deleted'] """ Check for active bids etc here - revisit if time (OOS) """ publication[5] = False Put(context, publication_key, Serialize(publication)) return [True, '']
def prop_info_update(ctx,id,hash,address): isOwner = CheckWitness(address) prop_owner = get_prop_owner(ctx,id) prop_info = get_prop_info(ctx, id) if prop_info == b'': print('The property is not registered yet') return False if isOwner == False: print('Contract caller different from address') return False if prop_owner != b'': if prop_owner != address: print('The property is registered to another address') return False if prop_info == hash: print('The property is already registered to caller address') return False delete_prop_from_user(ctx,prop_owner,prop_info) store_prop(ctx,id,hash,prop_owner) OnPropUpdate(id) return True
def perform_exchange(ctx, args): """ :param token:Token The token object with NEP5/sale settings :return: bool: Whether the exchange was successful """ if not CheckWitness(TOKEN_OWNER): print("Must be token owner to mint tokens") return False attachments = get_asset_attachments( args) # [receiver, sender, amount of tokens] exchange_ok = can_exchange(ctx, attachments, False) if not exchange_ok: return False # lookup the current balance of the address current_balance = Get(ctx, attachments[1]) # set the amount of tokens the receiver will get exchanged_tokens = attachments[2] new_total = exchanged_tokens + current_balance Put(ctx, attachments[1], new_total) # update the in circulation amount result = add_to_circulation(ctx, exchanged_tokens) # dispatch transfer event OnTransfer(attachments[0], attachments[1], exchanged_tokens) return True
def Main(operation, args): trigger = GetTrigger() if trigger == Verification(): print("Verification") return CheckWitness(token_owner) if trigger == Application(): if operation == "bet": if len(args) != 2 or args[1] == '': return False attachments = get_asset_attachments() sent_neo = attachments[2] sender = attachments[1] bet_id = args[0] option = args[1] print("sent_neo") print(sent_neo) if sent_neo > 0: bet(sender, bet_id, option, sent_neo) return True print("nothing matches") return False
def deploy(): """ :param token: Token The token to deploy :return: bool: Whether the operation was successful """ if not CheckWitness(TOKEN_OWNER): log = debug_log("Must be owner to deploy") return False if not Get(ctx, 'initialized'): # do deploy logic Put(ctx, 'initialized', 1) Put(ctx, TOKEN_OWNER, TOKEN_INITIAL_AMOUNT) Put(ctx, ECOSYSTEM_RESERVE_ADDRESS, TOKEN_ECOSYSTEM_AMOUNT) Put(ctx, ADVISOR_FUNDS_ADDRESS, TOKEN_ADVISOR_AMOUNT) Put(ctx, EMPLOYEE_FUNDS_ADDRESS1, TOKEN_EMPLOYEES_AMOUNT_1) Put(ctx, EMPLOYEE_FUNDS_ADDRESS2, TOKEN_EMPLOYEES_AMOUNT_2) Put(ctx, RESERVE_FUNDS_ADDRESS, TOKEN_RESERVE_AMOUNT) Put(ctx, AFFILIATE_FUNDS_ADDRESS, TOKEN_AFFILIATE_AMOUNT) Put(ctx, SALE_FUNDS_ADDRESS, TOKEN_SALE_AMOUNT) log = set_locked(ctx) return add_to_circulation(ctx, TOKEN_TOTAL_SUPPLY) return False
def DoMatch(src_order_key, dst_order_key, course): """ Method for the dApp owner to match exchange requests Input data: all not matched requests. Output data: matched pairs """ # Check if the method is triggered by the oracle for this exchange context = GetContext() src_order_data = Get(context, src_order_key) oracle = src_order_data[12] src_deposit_amount = src_order_data[10] dst_order_data = Get(context, dst_order_key) dst_deposit_amount = dst_order_data[10] if not CheckWitness(oracle): Log("Must be oracle to notice results") return False # refund deposit of the source wallet t1 = DoTransfer(DEPOSIT_WALLET, QUARK_WALLET, src_deposit_amount) # refund deposit of the source wallet t2 = DoTransfer(DEPOSIT_WALLET, QUARK_WALLET, dst_deposit_amount) if t1 and t2: DispatchExchangeEvent(src_order_key) DispatchExchangeEvent(dst_order_key) return True return False
def load_challenge_reserve(ctx, amount): if not CheckWitness(get_owner_address(ctx)): print("Needs to be the token owner.") return False if amount <= 0: print("Negative amount.") return False owner_balance = Get(ctx, get_owner_address(ctx)) if owner_balance < amount: print("The owner does not have enough balance.") return False current_challenge_reserve = Get(ctx, CHALLENGE_SYSTEM_RESERVE) if current_challenge_reserve + amount > CHALLENGE_SYSTEM_INITIAL_AMOUNT: print("Funds would exceed the maximum amount for challenge reserve.") return False print("Adding funds to the challenge reserve.") new_balance = owner_balance - amount Put(ctx, get_owner_address(ctx), new_balance) new_challenge_reserve = current_challenge_reserve + amount Put(ctx, CHALLENGE_SYSTEM_RESERVE, new_challenge_reserve) return True
def Main(operation, args): if operation == 'add_users': print("Running Verification!") is_owner = CheckWitness(OWNER) if is_owner: print("Is Owner!") return add_users(args) print("Not Owner") return False if operation == 'check_user': user = args[0] return check_user(user) if operation == 'current_vote': user = args[0] return current_vote(user) if operation == 'add_poll': poll = args[0] return add_poll(poll) if operation == 'vote': vote = args[0] return make_vote(vote)
def deploy(): """ :return: bool: Whether the operation was successful """ if not Get(ctx, 'initialized'): owner_initial_address = b'\xee\xee\xf8\xe5_\xde\x1aI\xed\xef\xca\xa5>\x17\x83?x\xf4\xff3' set_owner_address(ctx, owner_initial_address) if not CheckWitness(get_owner_address(ctx)): print("Must be owner to deploy") return False # do deploy logic Put(ctx, 'initialized', 1) # Allocate owner balance of 41 m Put(ctx, get_owner_address(ctx), TOKEN_OWNER_AMOUNT) # Allocate Challenge Reserve balance Put(ctx, CHALLENGE_SYSTEM_RESERVE, CHALLENGE_SYSTEM_INITIAL_AMOUNT) circulation = TOKEN_OWNER_AMOUNT + CHALLENGE_SYSTEM_INITIAL_AMOUNT Log("Deployed successfully!") # Add owner balance and challenge reserve balance to circulation return add_to_circulation(ctx, circulation) return False
def Main(operation, args): trigger = GetTrigger() # This is used in the Verification portion of the contract # To determine whether a transfer of system assets ( NEO/Gas) involving # This contract's address can proceed if trigger == Verification(): print("verification step") # check if the invoker is the owner of this contract is_owner = CheckWitness(TOKEN_OWNER) # If owner, proceed if is_owner: print("is owner") return True print("not owner") return False elif trigger == Application(): for op in NEP5_METHODS: if operation == op: return handle_nep51(ctx, operation, args) if operation == 'setToken': return setToken(args[0], args[1]) elif operation == 'bonusToken': return bonusToken(args[0], args[1]) elif operation == 'minusToken': return minusToken(args[0], args[1]) elif operation == 'getTime': return getCurrentTime() elif operation == "setProposal": # update: minusToken(args[1], args[4]) return setProposal(args[0], args[1], args[2], args[3], args[4]) elif operation == "getProposal": return getProposal(args[0]) elif operation == "upVote": return upVote(args[0], args[1]) elif operation == "downVote": return downVote(args[0], args[1]) elif operation == "isExped": return isExped(args[0]) elif operation == "isVoted": return isVoted(args[0], args[1]) return 'unknown operation' return False
def burn(ctx, args): """ Burn unsold tokens, main use case is for crowdsale. :param amount: int the amount to be burned :return: int: Whether the tokens were successfully burned or not """ amount = int(args[0]) if CheckWitness(TOKEN_OWNER): current_in_circulation = Get(ctx, TOKEN_CIRC_KEY) new_amount = current_in_circulation + amount if amount <= 0: return False if new_amount > TOKEN_TOTAL_SUPPLY: return False current_balance = Get(ctx, BURN_KEY) new_total = amount + current_balance Put(ctx, BURN_KEY, new_total) # update the in circulation amount # burned tokens is counted in circulation but removed from NEP5 totalSupply result = add_to_circulation(ctx, amount) # dispatch burn event OnBurn(amount) return True else: return False
def SetSubdomain(domain_name, subdomain): msg = concat("SetSubdomain: ", domain_name, subdomain) Notify(msg) context = GetContext() owner = Get(context, domain_name) if stringCompare(subdomain): Notify("Domain has incorrect char inside") return False if not owner: Notify("Domain is not yet registered") return False if not CheckWitness(owner): Notify("Sender is not the owner, cannot set subdomain") return False domain = concat(subdomain, ".") domain = concat(domain, domain_name) Put(context, domain, owner) msg2 = [domain, "is owned by ", owner] Notify(msg2) return True
def RegisterDomain(domain_name, owner): msg = concat("RegisterDomain: ", domain_name) Notify(msg) ''' Check if the domain contain . if ture then return false ''' if stringCompare(domain_name): Notify("Domain has incorrect char inside") return False if not CheckWitness(owner): Notify("Owner argument is not the same as the sender") return False context = GetContext() exists = Get(context, domain_name) if exists: Notify("Domain is already registered") return False Put(context, domain_name, owner) msg2 = [domain_name, "is owned by ", owner] Notify(msg2) return True
def reallocate(): """ Once the token sale is over, the owner can take back the remaining tokens. :return: bool: Whether the operation was successful """ if not CheckWitness(get_owner_address(ctx)): print("Must be owner to reallocate") return False time = GetTime() if time < SERIES_A_END: print("Must wait until the end of Series A before re-allocating.") return False current_balance = Get(ctx, get_owner_address(ctx)) crowdsale_available = crowdsale_available_amount(ctx) new_balance = current_balance + crowdsale_available Put(ctx, get_owner_address(ctx), new_balance) Log("Reallocated successfully!") return add_to_circulation(ctx, crowdsale_available)
def do_approve(ctx, t_owner, t_spender, amount): if len(t_spender) != 20: return False if not CheckWitness(t_owner): return False if amount < 0: return False # cannot approve an amount that is # currently greater than the from balance if Get(ctx, t_owner) >= amount: approval_key = concat(t_owner, t_spender) if amount == 0: Delete(ctx, approval_key) else: Put(ctx, approval_key, amount) 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 :return: bytearray: The result of the operation """ trigger = GetTrigger() # This is used in the Verification portion of the contract # To determine whether a transfer of system assets ( NEO/Gas) involving # This contract's address can proceed if trigger == Verification(): # check if the invoker is the owner of this contract is_owner = CheckWitness(TOKEN_OWNER) # If owner, proceed if is_owner: return is_owner # Otherwise, we need to lookup the assets and determine # If attachments of assets is ok attachments = get_asset_attachments() return can_exchange(ctx, attachments, True) elif trigger == Application(): for op in NEP5_METHODS: if operation == op: return handle_nep51(ctx, operation, args) if operation == 'deploy': return deploy() elif operation == 'circulation': return get_circulation(ctx) elif operation == 'ico_sold': return get_ico_token_sold(ctx) # the following are handled by crowdsale elif operation == 'mintTokens': return perform_exchange(ctx) elif operation == 'crowdsale_register': return kyc_register(ctx, args) elif operation == 'crowdsale_status': return kyc_status(ctx, args) elif operation == 'airdrop': return drop_tokens(ctx, args) return 'unknown operation' return False
def TransferFarmContract(FarmContract_name, OwnerNeoAddress, to_address): msg = concat("TransferFarmContract: ", FarmContract_name) msg2 = concat(msg, OwnerNeoAddress) Notify(msg2) storage_key = concat(FarmContract_name, OwnerNeoAddress) context = GetContext() Owner = Get(context, storage_key) if not Owner: Notify("This farm contract is not yet registered") return False if not CheckWitness(Owner): Notify( "This person is not the Owner, Farm Contract ownership cannot be Transfered" ) return False if not len(to_address) != 34: Notify("Invalid new owner neo address. Must be exactly 34 characters") return False putRegistry(context, storage_key, to_address) return True
def register_delegator(context, args): if not CheckWitness(OWNER): Notify(ILLEGAL_CALL) return False delegator = args[0] name = args[1] if len(delegator) != 20: Notify(INVALID_ADDRESS) return False if not name: Notify(MISSING_DELEGATOR_NAME) return False if Get(context, delegator): Notify(ALREADY_EXISTING_DELEGATOR) return False Notify(['[REGISTER-DELEGATOR] delegator:', delegator, 'name:', name]) Put(context, delegator, name) return True
def DeleteOrder(order_key): """ Method for the dApp owner to delete claimed or refunded exchanges :param order_key: order_key :type order_key: str :return: whether the deletion succeeded :rtype: bool """ if not CheckWitness(OWNER): Log("Must be owner to delete an exchange") return False context = GetContext() order_data = Get(context, order_key) status = order_data[12] if status == 'claimed': Delete(context, order_key) DispatchDeleteOrderEvent(order_key) elif status == 'refunded': Delete(context, order_key) DispatchDeleteOrderEvent(order_key) return False