Exemple #1
0
def Main(operation, arguments):
    print("Running DNS contract v1")
    trigger = GetTrigger()

    if len(arguments) < 1 or (operation == 'put' and len(arguments) < 2):
        return False

    if not is_valid_addr(arguments[0]):
        return False

    # This determines that the SC is running in Verification mode
    # This determines whether the TX will be relayed to the rest of the network
    # The `Verification` portion of SC is *read-only*, so calls to `Storage.Put` will fail.
    # You can, however, use `Storage.Get`
    if trigger == Verification():

        print("Running Verification!")
        if operation == 'put' or operation == 'delete':
            return CheckWitness(arguments[0])
        elif operation == 'get':
            return True

        return False

    elif trigger == Application():

        print("Running Application!")

        ctx = GetContext()

        if operation == 'put':
            Put(ctx, arguments[0], arguments[1])
            return True
        elif operation == 'get':
            return Get(ctx, arguments[0])
        elif operation == 'delete':
            Delete(ctx, arguments[0])
            return True

        return False

    return False
Exemple #2
0
def CurrentSwapRate():
    """
    Method to calculate the current 'going rate' or exchange ratio of NEO to NEP5 tokens

    :return: the current rate
    :rtype: int

    """
    basic = 1000 * FACTOR
    duration = ICO_END_TIME - ICO_START_TIME
    print("getting swap rate")
    context = GetContext()
    print("got context")

    total_supply = Get(context, 'totalSupply')
    print("got total supply")
    if total_supply >= TOTAL_AMOUNT:
        return False
    print("getting current height...")
    currentHeight = GetHeight()
    print("got current height")
    currentBlock = GetHeader(currentHeight)
    print("got current block...")
    time = currentBlock.Timestamp - ICO_START_TIME

    if time < 0:

        return 0

    elif time < 86400:
        return basic * 130 / 100

    elif time < 259200:
        return basic * 120 / 100

    elif time < 604800:
        return basic * 110 / 100

    elif time < duration:
        return basic

    return 0
Exemple #3
0
def register_proposal(args):
    """
    Register a New prosal
    :param args: list of arguments [PROPOSA ID, PROPOSAL DESCRIPTION, AUTHORIZED ADDR 1, AUTHORIZED ADDR N, ...]
    :return: bool, result of the execution
    """
    if len(args) < 4:
        return False

    # check proposal existence
    proposal_id = args[0]
    if Get(ctx, proposal_id):
        print("Already a Proposal")
        return False

    # proposal arguments
    proposal = []
    proposal.append(args[1])  # proposal description
    proposal.append(0)  # yes counter
    proposal.append(0)  # no counter

    # iterate from the third parameter to extract authorized addresses
    proposal_address = []
    index = 2
    while index < len(args):

        address = args[index]
        # check address format
        if len(address) != 20:
            print('bad address format')
            return False

        proposal_address.append(address)
        index += 1

    proposal.append(proposal_address)  # authorized addresses

    # serialize proposal and write to storage
    proposal_storage = Serialize(proposal)
    Put(ctx, proposal_id, proposal_storage)

    return True
Exemple #4
0
def deploy():
    """
    Deploy the contract: initialize all settings.
    """
    if not CheckWitness(CONTRACT_OWNER):
        return "Must be owner to deploy"

    if not Get(ctx, 'initialized'):
        # do deploy logic
        Put(ctx, 'initialized', 1)
        Put(ctx, AD_LIST_KEY, Serialize([]))
        Put(ctx, CONTRACT_OWNER, TOKEN_INITIAL_AMOUNT)
        # Set ICO Start and end date
        height = GetHeight()
        Put(ctx, BLOCK_SALE_START_KEY, height)
        Put(ctx, BLOCK_SALE_LIMIT_END_KEY, height + ICO_LIMITED_DURATION)

        return add_to_circulation(ctx, TOKEN_INITIAL_AMOUNT)

    return 'Deploy Failed'
def allowance(context, arguments):

    address = arguments[0]
    to = arguments[1]

    # Address has to be 20 bytes
    if len(address) != 20:
        print('Address is incorrect')
        return False

    # To address has to be 20 bytes
    if len(to) != 20:
        print('Address is incorrect')
        return False

    key = concat(address, to)

    # Return the allowance
    allowance = Get(context, key)
    return allowance
def register_wallet(context, args):
    if not CheckWitness(OWNER):
        Notify(ILLEGAL_CALL)
        return False

    wallet = args[0]

    if len(wallet) != 20:
        Notify(INVALID_ADDRESS)
        return False

    if Get(context, wallet):
        Notify(ALREADY_EXISTING_WALLET)
        return False

    Notify(['[REGISTER-WALLET] wallet:', wallet])

    Put(context, wallet, True)

    return True
Exemple #7
0
def exchange_token():
    tx = GetScriptContainer()
    references = tx.References
    sender_addr = None
    receiver_addr = GetExecutingScriptHash()
    sent_amount_neo = 0
    sender_addr = 1
    neo_amount = 0
    if len(references) > 0:
        reference = references[0]
        sender_addr = reference.ScriptHash
    for output in tx.Outputs:
        if output.ScriptHash == receiver_addr:
            neo_amount += output.Value
    if neo_amount == 0:
        return false
    exchanged_amount = neo_amount * 10
    current_balance = Get(ctx, sender_addr)
    Put(ctx, sender_addr, current_balance + exchanged_amount)
    return True
Exemple #8
0
def TransferRegistry(Registry_name, to_address):
    msg = concat("TransferRegistry: ", Registry_name)
    Notify(msg)

    context = GetContext()
    owner = Get(context, Registry_name)
    if not owner:
        Notify("Registry is not yet registered")
        return False

    if not CheckWitness(owner):
        Notify("This person is not the owner, Registry 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, Registry_name, to_address)
    return True
def deploy():
    """

    :param token: Token The token to deploy
    :return:
        bool: Whether the operation was successful
    """
    if not CheckWitness(TOKEN_OWNER):
        print("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)
        # dispatch transfer event for minting
        OnTransfer(None, TOKEN_OWNER, TOKEN_INITIAL_AMOUNT)
        return add_to_circulation(ctx, TOKEN_INITIAL_AMOUNT)

    return False
Exemple #10
0
def TransferFarm(Farm_name, to_address):
    msg = concat("TransferFarm: ", Farm_name)
    Notify(msg)

    context = GetContext()
    owner = Get(context, Farm_name)
    if not owner:
        Notify("Farm is not yet registered")
        return False

    if not CheckWitness(owner):
        Notify("This person is not the owner, farm ownership cannot transfer")
        return False

    if not len(to_address) != 34:
        Notify("Invalid new owner neo address. Must be exactly 34 characters")
        return False

    Put(context, Farm_name, to_address)
    return True
Exemple #11
0
def do_modify_uri(ctx, args):
    """Modifies token URI

    :param StorageContext ctx: current store context
    :param int t_id: token id
    :param str t_uri: token uri
    :return: URI modification success
    :rtype: bool
    """

    t_id = args[0]
    t_uri = args[1]

    token_key = concat('token/', t_id)
    token = safe_deserialize(Get(ctx, token_key))
    assert token, TOKEN_DNE_ERROR

    token['uri'] = t_uri
    Put(ctx, token_key, Serialize(token))
    return True
Exemple #12
0
def Transfer(domain, to):
    if to == None:
        return False

    context = GetContext()
    owner = Get(context, domain)
    if owner == None:
        return False
    if owner == to:
        return True

    is_owner = CheckWitness(owner)

    if not is_owner:
        return False

    Put(context, domain, to)
    Push('Transfer', domain)

    return True
Exemple #13
0
def transfer_asset(asset_id, to_address):
    msg = concat("TransferAsset: ", asset_id)
    Notify(msg)

    context = GetContext()
    owner = Get(context, asset_id)
    if not owner:
        Notify("Asset is not yet registered")
        return False

    if not CheckWitness(owner):
        Notify("Sender is not the owner, cannot transfer")
        return False

    if not len(to_address) != 34:
        Notify("Invalid new owner address. Must be exactly 34 characters")
        return False

    Put(context, asset_id, to_address)
    return True
Exemple #14
0
def bid_for_board(board_id, bidder, bid, content):
    if bid <= 0:
        ''' and other value checking'''
        return False

    highest_bid_key = get_highest_bid_key(board_id)
    highest_bid = Get(ctx, highest_bid_key)
    if bid > highest_bid:
        highest_bidder_key = get_highest_bidder_key(board_id)
        Put(ctx, highest_bidder_key, bidder)

        Put(ctx, highest_bid_key, bid)

        next_content_key = get_next_content_key(board_id)
        Put(ctx, next_content_key, content)
        return True

    else:
        print('Bid Smaller than Current Bid')
        return False
Exemple #15
0
def deploy():

    context = GetContext()

    if not CheckWitness(OWNER):

        return notifyErrorAndReturnFalse("Must be owner to deploy")

    if not Get(context, DEPLOYED_AT):

        current_time = GetTime()

        Put(context, DEPLOYED_AT, current_time)

        Put(context, OWNER, TOTAL_SUPPLY)

        DispatchTransferEvent(None, OWNER, TOTAL_SUPPLY)

    else:
        return notifyErrorAndReturnFalse("Already deployed!")
Exemple #16
0
def TransferDomain(domain_name, to_address):
    msg = concat("TransferDomain: ", domain_name)
    Notify(msg)

    context = GetContext()
    owner = Get(context, domain_name)
    if not owner:
        Notify("Domain is not yet registered")
        return False

    if not CheckWitness(owner):
        Notify("Sender is not the owner, cannot transfer")
        return False

    if not len(to_address) != 34:
        Notify("Invalid new owner address. Must be exactly 34 characters")
        return False

    Put(context, domain_name, to_address)
    return True
Exemple #17
0
def min_tokens(ctx, from_address, to_address, tokens):
    """
    Mint tokens for an address
        :param from_address: the address from which the tokens are being minted (should always be the contract address)
        :param to_address: the address to transfer the minted tokens to
        :param tokens: the number of tokens to mint
    """
    # lookup the current balance of the address
    current_balance = Get(ctx, to_address)

    new_total = current_balance + tokens

    #save new balance on the address
    Put(ctx, to_address, new_total)

    # update the in circulation amount
    result = add_to_circulation(ctx, tokens)

    # dispatch transfer event
    OnTransfer(from_address, to_address, tokens)
Exemple #18
0
def mint_tokens(ctx, address, amount):
    """
    Mint tokens for an address

    :param ctx:GetContext() used to access contract storage
    :param to_address: the address to add the tokens to
    :param amount:int the number of tokens to mint

    :return:bool Whether the operation was successful
    """

    # lookup the current balance of the address
    current_balance = Get(ctx, address)

    # add it to the the exchanged tokens and persist in storage
    new_total = amount + current_balance
    Put(ctx, address, new_total)

    # update the in circulation amount
    return add_to_circulation(ctx, amount)
def do_approve(ctx, t_owner, t_spender, t_id, revoke):

    if len(t_owner) != 20:
        return False

    if len(t_spender) != 20:
        return False

    if len(t_id) == 0:
        t_id = 0

    if len(revoke) == 0:
        revoke = 0

    t_owner = Get(ctx, t_id)

    if len(t_owner) != 20:
        print("token does not exist")
        return False

    if CheckWitness(t_owner):

        approval_key = concat("approved/", t_id)

        if revoke != 0:
            Delete(ctx, approval_key)
            OnApprove(t_owner, t_spender, 0)
            OnNFTApprove(t_owner, '', t_id)
            return True

        # only one third-party spender can be approved
        # at any given time for a specific token
        approved_spend = concat(t_owner, t_spender)
        Put(ctx, approval_key, approved_spend)
        OnApprove(t_owner, t_spender, 1)
        OnNFTApprove(t_owner, t_spender, t_id)

        return True

    print("Incorrect permission")
    return False
Exemple #20
0
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 a key for a value (likely a key to ipfs)
        args[2] is the value to be stored (likely ipfs hash)
    :param type: str

    :return:
        byterarray: The result of the operation
    """

    print("checking if authorized")
    # Am I who I say I am?
    user_hash = args[0]
    authorized = CheckWitness(user_hash)
    if not authorized:
        print("Not Authorized")
        return False
    print("Authorized")

    #blockchain key, is the key stored for the data stored (probably ipfs)
    blockchain_key = args[1]

    if operation == 'Save':
        print("operation = Save()")
        blockchain_value = args[2]
        Put(GetContext(), blockchain_key, blockchain_value)
        return True
    if operation == 'Get':
        print("operation = Get()")
        stored_value = Get(GetContext(), blockchain_key)
        if stored_value:
            return stored_value

    return False
def register(ctx, args):
    """
    Register new account

    Args:
        0 -> script hash of invoker
        1 -> unique user id
        2 -> display name
    Account storage uid => array[]:
        0 -> script hash of invoker
        1 -> uid
        2 -> display name
        3 -> time of registration
        4 -> count tweets
        5 -> count followers
        6 -> count following
        7 -> count unfollowed
        8 -> count unfollowing
    """
    addr = args[0]
    uid = args[1]
    # check if uid is free
    if not Get(ctx, uid):
        # check if user already registered
        if not isRegistered(ctx, addr):
            # register the script hash with the uid
            Put(ctx, addr, uid)
            name = args[2]
            time = GetTime()
            save = [addr, uid, name, time, 0, 0, 0, 0, 0]
            save_s = Serialize(save)
            # register the uid with user data
            Put(ctx, args[1], save_s)
            # Increment total account count + 1
            IncrementOne(ctx, "accounts")
            OnRegister(addr, uid)
            return True
        Notify("User is already registered")
        return False
    Notify("UserId already taken")
    return False
Exemple #22
0
def transfer_to_smart_contract(ctx, t_from, args, is_mint):
    """Transfers a token to a smart contract and triggers the
    receiving contract's onNFTTransfer event.

    :param StorageContext ctx: current store context
    :param byte[] t_from: transfer from address (who is sending the NFT)
    :param list args:
        0: byte[] t_to: transfer to address (who is receiving the NFT)
        1: bytes t_id: token id
        2: extra_arg (optional)
    :param bool is_mint: whether or not the token is being minted
    :return: transfer success
    :rtype: bool
    """
    t_to = args[0]
    t_id = args[1]

    if len(t_from) != 20 or len(t_to) != 20:
        Notify(INVALID_ADDRESS_ERROR)
        return False

    # invoke the onNFTTransfer operation of the recipient contract,
    # if it returns False, then reject the transfer
    success = DynamicAppCall(t_to, 'onNFTTransfer', args)

    if success is False:
        Notify('transfer rejected by recipient contract')
        return False

    # need to check funds again in case a transfer or approval
    # change happened inside the onTokenTransfer call
    # the `is_mint` check is needed because you can't get the token
    # owner for a token that hasn't finished being minted yet
    if is_mint is False:
        t_owner = Get(ctx, t_id)
        if t_owner != t_from:
            Notify('insufficient funds')
            return False

    Log('transfer accepted by recipient contract')
    return True
Exemple #23
0
def create(data):
    """

    Parameters
    ----------
    data : boa.builtins.list
        The input data containing an address and a hash, both in bytes

    Returns
    -------
    bool
        Returns False if the entry does exist already, otherwise True
    """

    if Get(ctx, data[IDX_KEY]):
        print('Error: Entry already exists!')
        return False

    data_serialized = serialize_data(data)
    Put(ctx, data[IDX_KEY], data_serialized)
    return True
Exemple #24
0
def has_user_participated(account):

    if len(account) != 20:
        return notifyErrorAndReturnFalse("Account should be 20-byte addresses")

    context = GetContext()

    current_game_no = get_current_game_no()

    flag = concat(PLAYER, account)

    flag = concat(flag, current_game_no)

    flag = concat(flag, "first")

    check_user_participation = Get(context, flag)

    if check_user_participation:
        return True

    return False
Exemple #25
0
def perform_exchange(ctx):
    """

     :param token:Token The token object with NEP5/sale settings
     :return:
         bool: Whether the exchange was successful
     """
    attachments = get_asset_attachments()  # [receiver, sender, gas]

    current_balance = Get(ctx, attachments[1])

    exchanged_tokens += attachments[2] * TOKENS_PER_GAS

    # add it to the the exchanged tokens and persist in storage
    new_total = exchanged_tokens + current_balance
    Put(ctx, attachments[1], new_total)

    # update the in circulation amount
    result = add_to_circulation(ctx, exchanged_tokens)

    return True
Exemple #26
0
def UnregisterFarmContract(FarmContract_name, OwnerNeoAddress):
    msg = concat("UnregisterFarmContract: ", 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("FarmContract is not yet registered")
        return False

    if not CheckWitness(owner):
        Notify(
            "This person is not the owner of the FarmContract, the FarmContract cannot be deleted"
        )
        return False

    removeRegistry(context, storage_key)
    return True
def generateAlien(xna, alienName, blockHeight):

    context = GetContext()
    counter = Get(context, 'counter')
    if not counter:
        Put(context, 'counter', 1)
    else:
        Put(context, 'counter', counter + 1)
    counter += 1

    temp_alien = {
        'xna': xna,
        'alienName': alienName,
        'blockHeight': blockHeight,
        'id': counter
    }

    Put(context, temp_alien['id'], Serialize(temp_alien))
    Notify(concat("Alien created, ID: ", temp_alien['id']))

    return temp_alien
Exemple #28
0
def register_ad(senderhash, ad_id, ad_description, lat_lng, ad_exp, ad_views,
                ad_sell, ad_price):

    ad_exists = Get(ctx, ad_id)
    Notify("Ad exists works ")
    ad_data = list(length=8)

    #senderhash
    ad_data[0] = senderhash
    ad_data[1] = ad_id

    #ad description
    ad_data[2] = ad_description

    #lat and long
    ad_data[3] = lat_lng

    # ad expiration
    ad_data[4] = ad_exp

    # total views
    ad_data[5] = ad_views

    #auto sell
    ad_data[6] = ad_sell

    #price in gas
    ad_data[7] = ad_price

    if not ad_exists:
        Notify("Ad does not exist")
        serialized_ad_data = serialize_array(ad_data)
        Notify("Data Serialized ")
        Put(ctx, ad_id, serialized_ad_data)
        Notify("ad registered")
        Notify(serialized_ad_data)

    else:
        Notify("Ad Exists")
        return False
Exemple #29
0
def GetAllowance(t_owner, t_spender):
    """
    Gets the amount of tokens that a spender is allowed to spend
    from the owners' account.

    :param t_owner: Owner of tokens
    :type t_owner: bytearray
    :param t_spender: Requestor of tokens
    :type t_spender: bytearray

    :return: Amount allowed to be spent by Requestor on behalf of owner
    :rtype: int

    """

    context = GetContext()

    allowance_key = concat(t_owner, t_spender)

    amount = Get(context, allowance_key)

    return amount
def print_info(adr):
    """
        Prints the information stored in the blockchain for the given address
        :return: indication success execution of the command
        :rtype: bool
    """
    termsba = Get(ctx, adr)
    if not termsba:
        Notify("Partnership for address is not yet created")
        return False

    serterms = deserialize_bytearray(termsba)
    currency = serterms[0]
    flatfees_struc = serterms[1]
    partnership_struc = serterms[2]
    webpage = serterms[3]
    msg = concat("Partnership Information:", " ")
    a = concat("Address : ", adr)
    msg = concat(msg, a)
    c = concat(", Currency : ", currency)
    msg = concat(msg, c)
    d = concat(", Flatfee Structure : ", flatfees_struc)
    msg = concat(msg, d)
    e = concat(", Partnership Structure: ", partnership_struc)
    msg = concat(msg, e)
    f = concat(", Webpage: ", webpage)
    msg = concat(msg, f)
    Notify(msg)

    json_like_string = concat('["', currency)
    json_like_string = concat(json_like_string, '","')
    json_like_string = concat(json_like_string, flatfees_struc)
    json_like_string = concat(json_like_string, '","')
    json_like_string = concat(json_like_string, partnership_struc)
    json_like_string = concat(json_like_string, '", "')
    json_like_string = concat(json_like_string, webpage)
    json_like_string = concat(json_like_string, '"]')

    return json_like_string