# Code

**Python**

The main programming language used for Decentralized Decisions development is Python. Python is a general purpose interpreted programming language. However, other languages such as JavaScript may also be used for variations of the software.

**Hash Function**

```
# Hash function to secure data using quantum secure hash. 
def hash(item):
    # Assumes the default UTF-8.
    # This encodes the string with the SHA-512 scheme.
    hash_object = hashlib.sha512(item.encode()) 
    # This returns the hexadecimal encode as a string.
    item = hash_object.hexdigest() 
    return item
```

The hash function converts a string to a secure code using the SHA-512 cryptographic scheme. SHA-512 is a post-quantum cryptographic scheme, thus ensuring that private information is made secure from malicious attackers.

**Vote Functions**

```
# The voting function allows the decision to happen.
def choice_vote(sender, key, receiver,amount,comment):
    parameters = algod_client.suggested_params() # Sets suggested parameters
    transaction = AssetTransferTxn(sender, parameters, receiver, amount, choice_id,note=comment)
    # Defines an inital transaction for Choice Coin
    signature = transaction.sign(key)
    # Signs the transaction with the senders private key
    algod_client.send_transaction(signature)
    # Sends the transaction with the signature
    final = transaction.get_txid()
    return True, final
```

The `choice_vote` function defines a stateless smart contract on the Algorand Network. It sends Choice Coin to the appropriate destination address based on user input.

```
def vote():
    voter = input(str("Vote 0 for zero and vote 1 for one:"))
    params = algod_client.suggested_params()
    if voter is str('1'):
        # send one choice to address
        amount = 100
        transaction = AssetTransferTxn(sender=voter_address, sp=params, receiver=vote_address, amt=amount, index=asset_id)
        signature = transaction.sign(voter_phrase)
        algod_client.send_transaction(signature)
        final = transaction.get_txid()
        print ("Thanks for voting for one.")
        print(final)
    else:
        # do not send one choice to address
        print ("Thanks for voting for zero.")
```

Here, the `vote` function uses a simple binary to send one Choice to an address with a positive vote, or takes no action with a negative vote. The amount is set to 100 to account for the two decimals places associate with the Choice asset. Below is another `vote` function, which uses two addresses instead of one.

```
def vote():
    voter = input(str("Vote 0 for zero and vote 1 for one:"))
    params = algod_client.suggested_params()
    if voter is str('1'):
        # send one choice to address
        amount = 100
        vote_address = ""
        transaction = AssetTransferTxn(sender=voter_address, sp=params, receiver=vote_address, amt=amount, index=asset_id)
        signature = transaction.sign(voter_phrase)
        algod_client.send_transaction(signature)
        final = transaction.get_txid()
        print ("Thanks for voting for one.")
        print(final)
    else:
        amount = 100
        vote_address = ""
        transaction = AssetTransferTxn(sender=voter_address, sp=params, receiver=vote_address, amt=amount, index=asset_id)
        signature = transaction.sign(voter_phrase)
        algod_client.send_transaction(signature)
        final = transaction.get_txid()
        print ("Thanks for voting for zero.")
        print(final)
```

Here, each option has an associated address. This allows for a simple count of each address to determine the total number of votes.

**Results Functions**

```
# The count_votes funciton counts the votes to determine the winner.
def count_votes():
    yes_count = count(decision_one)
    no_count = count(decision_two)
    show_results(yes_count,no_count)
    if yes_count > no_count:
        return "The Voting Process has ended. Choice One had the most votes!"
    else no_count > yes_count:
        return "The Voting Process has ended. Choice Two had the most votes!"
```

This function counts the total number of votes to return a statement regarding which candidate has won. This model may apply to both corporate or electoral voting.

```
def check_results():
    asset_id = 42771692 
    address = ""
    account_info = client.account_info(address)
    assets = account_info.get("assets")
    for asset in assets:
        if asset['asset-id'] == asset_id:
            amount = asset.get("amount")
            print("Account {} has {}.".format(address, balance_formatter(amount, asset_id, client)))
            return
        print("Account {} must opt-in to Asset ID {}.".format(address, asset_id))
check_results()
```

Here, the `check_results` function checks the amount the asset in the account, to determine the total number of votes for the particular address.

**Links**

Decentralized Decisions GitHub: <https://github.com/ChoiceCoin/Voting>

Decentralized Decisions White Paper: <https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3913316>

Python GitHub: <https://github.com/python>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://choice-coin.gitbook.io/choice-coin-docs/decentralized-decisions/code.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.