DEV Community: Muwawu Moses

How to use 'initializes' and 'exports' in vyper: Modular Vyper code arrangement.

Muwawu Moses — Thu, 29 Aug 2024 13:32:15 +0000

As vyper is evolving, a lot of new exciting changes have been introduced in version 0.4.0. Today, we are going to put our focus on two built-in functions: initializes and exports.

initializes

This mainly is useful when you need to initialize a module's state.

In Vyper, @external functions are not automatically exposed (i.e., included in the runtime code) in the importing contract. This means that any externally facing functionality must be explicitly defined in the top-level of the compilation target.
So, exporting external functions from modules is accomplished using the exports keyword.

Anyway, to better understand these, we shall use a code example.
I am going to illustrate using three contracts i.e A.vy, B.vy and C.vy where A.vy is the module we gonna be utilizing.
A.vy

#pragma version >0.3.10

x: public(uint256)
y: public(uint256)
z: public(uint256)

@deploy
def __init__(_x: uint256, _y: uint256):
    self.x = _x
    self.y = _y

@external
def add(_x: uint256, _y: uint256):
    self._add(_x, _y)

@internal
def _add(_x: uint256, _y: uint256):
    _z: uint256 = _x + _y
    self.z = _z

B.vy

#pragma version >0.3.10

from . import A
initializes: A

@deploy
def __init__(_x: uint256, _y: uint256):
    A.__init__(_x, _y)

@external
def set_value(_x: uint256, _y: uint256):
    A._add(_x, _y)

@view
@external
def get_x() -> uint256:
    _x: uint256 = A.x
    return _x

@view
@external
def get_y() -> uint256:
    _y: uint256 = A.y
    return _y

@view 
@external
def get_z() -> uint256:
    result: uint256 = A.z
    return result

C.vy

#pragma version >0.3.10

from . import A
initializes: A

exports: A.add


@deploy
def __init__(_x: uint256, _y: uint256):
    A.__init__(_x, _y)

@view
@external
def get_x() -> uint256:
    _x: uint256 = A.x
    return _x

@view
@external
def get_y() -> uint256:
    _y: uint256 = A.y
    return _y

@view 
@external
def get_z() -> uint256:
    result: uint256 = A.z
    return result

From the above code examples in contract B.vy, we can see that we use A.vy's state by initializing using the initializes: A magic. Also, i can access all @internal functions of the initialized contract. For example, I can call A._add(_x, _y). However, it's not possible to call external functions at this moment. A.add(_x, _y) will throw. To archive this, we need to use exports: A.add just like it's done in C.vy.
With exports, the external function is now available in the initializing contract. We are going to witness this later when it comes to interacting with the code.
scripts/deploy_B.py

from ape import project, accounts

def main():
    account = accounts.load('meta_wallet')  # Replace with your actual account alias
    _x = 3
    _y = 4
    # Deploy the contract
    contract = account.deploy(project.B, _x, _y)  # Initial values for x and y

    # Display initial values
    print(f"Initial x: {contract.get_x()} \u2705")
    print(f"Initial y: {contract.get_y()} \u2705")

    # Call the add method
    contract.set_value(5, 15, sender=account)

    # Fetch and display the result
    result = contract.get_z()
    print(f"Result (z): {result} \u2705")

From the image above, we see that we get exactly what we expect from the way how initializes and exports operate.✅
scripts/deploy_C.py

from ape import project, accounts

def main():
    account = accounts.load('meta_wallet')  # Replace with your actual account name
    _x = 5
    _y = 10
    # Deploy the contract
    contract = account.deploy(project.C, _x, _y)  # Initial values for x and y

    # Display initial values
    print(f"Initial x: {contract.get_x()} \u2705")
    print(f"Initial y: {contract.get_y()} \u2705")

    # Call the add method
    contract.add(5, 15, sender=account)

    # Fetch and display the result
    result = contract.get_z()
    print(f"Result (z): {result} \u2705")

Here also, you see that we can access the contract state of A just buy initializing and exporting it's external functions.✅ Therefore, one can just call from C, contract.add().

Thanks for reading. Let me hope my efforts help you at some stage. If you find the post helpful, please don't forget to give a like, and comment below if you need any help.

A Simple Vyper smart contract to fetch the price of BTC using Chainlink and Apeworx.

Muwawu Moses — Fri, 28 Jun 2024 06:27:42 +0000

In this tutorial, we are going to navigate the basics of consuming a price feed oracle from Chainlink using the Apeworkx(ape) framework and vyper. We are going to connect to the ethereum network using Sepolia via Alchemy.

Prerequisites:

Development environment already setup
Metamask wallet set up
Configured Metamask to use LINK tokens.

Procedure:

Since we have everything ready including the development environment, we can now begin. Activate your virtual environment in the terminal and run ape init to initialize the ape project. Go on and provide the project name of your choice.

Open the ape-config.yaml file and add the following code;

dependencies:
  - name: chainlink
    github: smartcontractkit/chainlink-mix
    branch: main

The above code will ensure that chainlink is installed into our environment as a dependency.

Next, we are going to write our smart contracts. Navigate to the contracts folder and create a new folder interfaces. Inside the interfaces folder, add a file named AggregatorV3Interface.vy:

#pragma version ^0.3.10


@external
@view
def decimals() -> uint8:
    return 0


@external
@view
def description() -> String[1000]:
    return ""


@external
@view
def version() -> uint256:
    return 0


@external
@view
def getRoundData(_roundId: uint80) -> (uint80, int256, uint256, uint256, uint80):
    return (0, 0, 0, 0, 0)


@external
@view
def latestRoundData() -> (uint80, int256, uint256, uint256, uint80):
    return (0, 0, 0, 0, 0)

Within the contracts folder, add a new file; test/PriceConsumer.vy

# SPDX-License-Identifier: MIT
#pragma version ^0.3.10

import contracts.interfaces.AggregatorV3Interface as AggregatorV3Interface

price_feed: public(AggregatorV3Interface)

@external
def __init__(_price_feed_address: address):
    self.price_feed = AggregatorV3Interface(_price_feed_address)

@external
@view
def get_latest_price() -> int256:
    a: uint80 = 0
    price: int256 = 0
    b: uint256 = 0
    c: uint256 = 0
    d: uint80 = 0
    (a, price, b, c, d) = self.price_feed.latestRoundData()
    return price

Our code is now ready to compile. Please note that you should have an internet connection for this compilation to be successful because the project has to install chainlink as dependency before compiling.

Deployment:

In the scripts folder, let's create a file named deploy.py

from ape import accounts, project

def main():
    account = accounts.load("my_wallet")
    aggregator_address = "0x1b44F3514812d835EB1BDB0acB33d3fA3351Ee43"
    contract = account.deploy(project.PriceConsumer, aggregator_address)
    print(f"Contract deployed at: {contract.address}")


if __name__ == "__main__":
    main()

Here, i will mainly talk about the aggregator_address = "0x1b44F3514812d835EB1BDB0acB33d3fA3351Ee43". Where do we get it? Chainlink provides price feed addresses for all supported assets. So, you just have to copy and paste the address of your desired pair. To me, it's BTC-USD. To deploy the contract, run the command; ape run deploy --network ethereum:sepolia:alchemy

After successfully deploying the contract, copy the contract address because we are going to use for interacting with the contract.

Interacting with contract:

There are two ways in which we can interact with the deployed contract i.e through the console and through python scripts.

console

In your vs code terminal, run; ape console --network ethereum:sepolia:alchemy

In [1]: account = accounts.load("my_account")
Please enter passphrase to unlock 'my_account': 
In [2]: contract_address = "YourDeployedContractAddress"
In [3]: contract = project.PriceConsumer.at(contract_address)
In [4]: latest_price = contract.get_latest_price()
In [5]: print(f"The latest BTC price is: {latest_price / 1e8} USD")
The latest BTC price is: 61744.39100403 USD

my_account is the alias used for your ape imported account from metamask.

Using scripts

First, we should update the ape-config.yaml file so as to set the default network from ethereum:local:test to ethereum:sepolia:alchemy

name: price-checker

dependencies:
  - name: chainlink
    github: smartcontractkit/chainlink-mix
    branch: main

vyper:
  version: 0.3.10

ethereum:
  default_network: sepolia
  sepolia:
    default_provider: alchemy

default_ecosystem: ethereum

In the scripts folder, create a new file get_price.py

from ape import accounts, project,networks

def main():
    contract_address = "0x4Aac9382A3Cbb489DE2c67353a587983b9080343"


    # Load the deployed contract
    contract = project.PriceConsumer.at(contract_address)
    latest_price = contract.get_latest_price()
    print(f"The latest BTC price is: {latest_price / 1e8 } USD")

if __name__ == "__main__":
    main()

For eductaion purposes, we can go for a more straight forward approach(without setting up the ape-config.yaml file) often used for multi-network scripting. get_price2.py:

import click
from ape.cli import ape_cli_context
from ape import project

@click.command()
@ape_cli_context()
def cli(cli_ctx):
    # There is no connection yet at this point.
    testnets = {
        "ethereum": ["sepolia"]
    }
    nm = cli_ctx.network_manager

    for ecosystem_name, networks in testnets.items():
        ecosystem = nm.ecosystems[ecosystem_name]

        for network_name in networks:
            # Start making connections.
            network = ecosystem.get_network(network_name)

            with network.use_provider("alchemy") as provider:
                print(f"Connected to {provider.network_choice}")
                contract_address = "0x4Aac9382A3Cbb489DE2c67353a587983b9080343"


                # Load the deployed contract
                contract = project.PriceConsumer.at(contract_address)
                latest_price = contract.get_latest_price()
                print(f"The latest BTC price is: {latest_price / 1e8 } USD")

Congratulations if you have reached up to this stage. Please like and follow if you found this post helpful

How to compile, deploy and interact with smart contracts using Apeworx(ape) and VS Code.

Muwawu Moses — Sat, 01 Jun 2024 11:34:44 +0000

Today, we are going to write our smart contracts using Vyper and the Apeworx framework. We are going to connect to the ethereum network using Sepolia via Alchemy.

Prerequisites

python version later than 3.8
pip installed
metamask wallet already set up

Procedure

First, we are going to set up the development environment. Remember, when using windows, it's recommended to use WSL2 for development purposes. I am using Ubuntu for this tutorial.

Let's create a project folder named testing. mkdir testing
Then, navigate through the folder: cd testing
Create a virtual environment named .venv python3 -m venv .venvand then, run code . to open vs code. In the VS code terminal, activate the virtual environment by running source .venv/bin/activate

Next, we are going to install apeworx and all dependencies through a single command: pip install eth-ape'[recommended-plugins]'.

After a successful installation, we are now going to connect our project to the metamask wallet through creation of what is called an account.

Run ape accounts import meta_wallet In the above command, we have named our account 'meta_wallet'(you can name it anything you want). You'll then be prompted to enter private key and create a passphrase to encrypt your account.

Enter Private Key: 
Create Passphrase to encrypt account: 
Repeat for confirmation:

To enter private key, go to your metamask wallet and copy a private key and securely save it somewhere. Paste it into the terminal and please note that you won't be able to see it so, don't paste more than once.
For a passphrase, create something that you won't forget.
To confirm if your account has been imported, run ape accounts list.

One more last thing to do for a successful set up is adding the Alchemy-api-key to our settings.
Run code ~/.bashrc to open the bashrc file. In this file, add the following line of code("YOUR_ALCHEMY_API_KEY" with the actual api key from alchemy) to the bottom end of it: `export WEB3_ALCHEMY_API_KEY="YOUR_ALCHEMY_API_KEY"

Another option is to run export WEB3_ALCHEMY_API_KEY=<your_api_key> in your terminal

Lastly, run source ~/.bashrc so as to save the above changes
`
Note: If you are running your program on a testnet, please make sure that your alchemy ethereum app is a testnet not a mainnet.

Good that we are now done with the set up process, let's go for the actual business.
We shall start by initializing a project by running ape init.
This creates creates a project structure including; .build(for storage of artifacts), scripts folder, tests folder, contracts folder, and the ape-config.yaml file.

Add the following code to the ape-config.yaml file:

# ape-config.yaml
name: my-contract


ethereum:
  default_network: sepolia
  sepolia:
    default_provider: alchemy

default_ecosystem: ethereum

First, in the contracts folder, let's create a new file named Greeting.vy and add the following code.

#pragma version >0.3.10

greeting: public(String[120])

@deploy
def __init__(_word: String[120]):
    self.greeting = _word

@external
def set_string(_word: String[120]):
    self.greeting = _word

Explanation

The set_string function is for setting a string that doesn't exceed 120 characters and the greeting variable is an automatic get()function since it's marked public.

Next is to compile our code: ape compile.
Please note that after running the above command, a new file named __local__.json is automatically created in the .build folder. This file contains the abi and bytcode of the contract.

contract deployment

So, our next task is to create a another file named deploy.py in the scripts folder:

from ape import accounts, project

def main():
    # Use an existing account or create a new one
    deployer = accounts.load("meta_wallet")

    # we are initializing our contract with following string
    _hello = "Good Morning, Uganda!"

    # Deploy the Greeting Contract
    greeting_contract = deployer.deploy(project.Greeting, _hello)

    print(f"Greeting Contract deployed at: {greeting_contract.address}")

Run ape run deploy --network ethereum:sepolia:alchemy .
Congratulations if your deployment was a successful one.

calling a function

We can interact with the contract using ape:

# scripts/interact.py
from ape import project, accounts

def main():
    # Use your preferred account, e.g., the default one
    contract_address = "<copy_and_paste_here_contract_address>"

    contract = project.Greeting.at(contract_address)  # `Greeting` is contract name

    # view string
    result = contract.greeting()

    print(f"Result: {result}")

Run: ape run interact --network ethereum:sepolia:alchemy

Calling the set_string() function

# scripts/set_string.py
from ape import networks, accounts, project

def update_string_in_contract(new_string: str, contract_address: str, network_name: str, account_alias: str):
    """
    Function to update a string value in a smart contract on the specified network.

    :param new_string: The new string value to set in the contract.
    :param contract_address: The address of the smart contract.
    :param network_name: The network where the contract is deployed (e.g., 'arbitrum:sepolia:alchemy').
    :param account_alias: The alias of the account to use for the transaction (e.g., 'meta_wallet').
    :return: Transaction receipt or an error message.
    """
    try:
        with networks.parse_network_choice(network_name) as net:
            # Load the contract
            contract = project.Greeting.at(contract_address)

            # Prepare and send the transaction
            account = accounts.load(account_alias)
            tx = contract.set_string(new_string, sender=account)

            # Poll for the transaction receipt using `tx.txn_hash`
            receipt = net.provider.get_receipt(tx.txn_hash)

            if receipt.failed:
                return "Transaction failed"

            return {"result": "String updated successfully", "transaction_hash": tx.txn_hash}
    except Exception as e:
        return f"An error occurred: {str(e)}"

# Example usage
if __name__ == "__main__":
    new_string = "Unity is strength. Unity is Power. Unity is Humanity."
    contract_address = '<your_contract_address>'
    network_name = 'arbitrum:sepolia:alchemy'
    account_alias = 'meta_wallet'

    result = update_string_in_contract(new_string, contract_address, network_name, account_alias)
    print(result)

Wow! we have had our smart contract compiled, deployed and interacted with all in vs code. If you found this article helpful, don't hesitate to give me a like and please follow for more. Thank You!

Vyper: For loops and Arrays.

Muwawu Moses — Wed, 29 May 2024 06:54:36 +0000

Vyper is a pythonic language but does not support dynamic arrays or strings as extensively as Python. Therefore, there are certain guidelines to follow if one is to play around with for loops and arrays. In this tutorial, we are going use examples for a better understanding of how things work.


@external
def iterate_array_variable() -> int128:
    marks: int128[4] = [45, 67, 90, 36]
    result: int128[4] = [0, 0, 0, 0]
    for x in range(4):
        result[x] = marks[x] * 2
    return result[2]

In the example above, we define a function iterate_array_variable that returns a variable of type int128. We then define an array marks which must contain 4 literals of type int128. result is also an array defined just like marks. Their only difference are the values in these two arrays i.e [45, 67, 90, 36] and [0, 0, 0, 0]. The aim of this function is give the result array new values from result[x] = marks[x] * 2.

We expect the function to return the result to have a new value for each iteration performed. For example, at the third position(result[2]), the value must change from 0 to 180

Interacting with the contract

import sys
from web3 import Web3

# Connect to BSC node (Binance Smart Chain)
bsc_node_url = 'https://data-seed-prebsc-1-s1.binance.org:8545/'  # Replace with your BSC node URL
web3 = Web3(Web3.HTTPProvider(bsc_node_url))

# Set the private key directly (For demonstration purposes only, do not hardcode in production)
private_key = 'Your_private_key'  # Replace with your actual private key
account = web3.eth.account.from_key(private_key)

# Contract ABI
contract_abi = [
    Your_abi
]
# Contract address
contract_address = web3.to_checksum_address('your_contract_address')  # Replace with your contract's address

# Create contract instance
contract = web3.eth.contract(address=contract_address, abi=contract_abi)


# Function to set a choice
def call_iterate_array_variable():
    nonce = web3.eth.get_transaction_count(account.address)
    tx = contract.functions.iterate_array_variable().build_transaction({
        'chainId': 97,  # BSC testnet
        'gas': 3000000,
        'gasPrice': web3.to_wei('5', 'gwei'),
        'nonce': nonce,
    })
    signed_tx = web3.eth.account.sign_transaction(tx, private_key)
    tx_hash = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
    receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
    result = contract.functions.iterate_array_variable().call()
    return result

def main():
    result = call_iterate_array_variable()
    print(f'Result of the calculation: {result}')

if __name__ == "__main__":
    main()

Result

Iterating through the values of an array variable

y: public(int128)
@external
def iterate_array_variable() -> int128:
    marks: int128[4] = [45, 67, 90, 36]
    for x in marks:
        self.y = x
    return self.y

In the above example, we iterate through the values of the variable marks. We expect the function to return 36 since it will be the last value assigned to y after the iteration.

One may ask, what if we want to return a given value from such an array? The answer lies in the assert statement which is used for boolean operations.

y: public(int128)

@external
def get_mark(index: int128) -> int128:
    marks: int128[4] = [45, 67, 90, 36]
    assert 0 <= index, "Index out of lower limit"
    assert index < 4, "Index out of upper limit"
    self.y = marks[index]
    return self.y

In the above example, it's quite evident that we can explicitly determine the value we want to access by simply providing the index of that value from an array. assert 0 <= 4 makes sure that the index is greater or equal to zero. If not, the execution of the contract shall be reverted with the 'Index out of lower limit' error message. assert index < 4 behaves in the same manner but with different logic.

Interacting with the contract

from web3 import web3

"""
.......
......
Other code here
......
....
"""

# Create contract instance
contract = web3.eth.contract(address=contract_address, abi=contract_abi)


# Function to set a choice
def call_get_mark(index):
    nonce = web3.eth.get_transaction_count(account.address)
    tx = contract.functions.get_mark(index).build_transaction({
        'chainId': 97,  # BSC testnet
        'gas': 3000000,
        'gasPrice': web3.to_wei('5', 'gwei'),
        'nonce': nonce,
    })
    signed_tx = web3.eth.account.sign_transaction(tx, private_key)
    tx_hash = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
    receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
    result = contract.functions.get_mark(index).call()
    return result

def main():
    index = int(input("Enter the index (0 to 3): "))
    result = call_get_mark(index)
    print(f'Result of the calculation: {result}')

if __name__ == "__main__":
    main()

We can also iterate over a literal array:

# declaring variable y
y: public(int128)

@external
def non_dictated() -> int128:
    for x in [34, 76, 89, 45]:
        self.y = x
    return self.y

The above code will return 45 since it's the last value that will be stored in variable y.

Range Iteration

At the very beginning of this article, we saw one user case of range, for x in range(4):. Ranges are created using the range function. The example above follows a structure; for i in range(STOP): where STOP is a literal integer greater than zero.

Another use of range can be with START and STOP bounds.

for i in range(START, STOP):
    ...

Here, START and STOP are literal integers, with STOP being a greater value than START. i begins as START and increments by one until it is equal to STOP.

Example


@external
def iterate_array_variable() -> int128:
    marks: int128[4] = [45, 67, 90, 36]
    result: int128[4] = [0, 0, 0, 0]
    for x in range(1, 2):
        result[x] = marks[x] * 2
    return result[3]

When run, the above code will throw an error since the index specified by result[3], fourth position, exceeds the range of two positions from second to the third one.

Another important example is;

for i in range(stop, bound=N):
    ...

Here, stop can be a variable with integer type, greater than zero. N must be a compile-time constant. i begins as zero and increments by one until it is equal to stop. If stop is larger than N, execution will revert at runtime. In certain cases, you may not have a guarantee that stop is less than N, but still want to avoid the possibility of runtime reversion. To accomplish this, use the bound= keyword in combination with min(stop, N) as the argument to range, like range(min(stop, N), bound=N). This is helpful for use cases like chunking up operations on larger arrays across multiple transactions.

To better understand this, we need to first understand compile-time constant and run-time reversion.

Runtime reversion refers to the behavior of the contract when it encounters an error during execution. If a condition in the contract is not met or an exception is thrown, the contract will revert to its previous state before the transaction. This ensures that no partial or erroneous changes are made to the blockchain state. For example, using assert or require statements can trigger a reversion if the condition fails.

# compile-time constant
MAX_SUPPLY: constant(uint256) = 1000000

# if amount is not greater than zero, 
# the transaction will revert at runtime, 
# ensuring the contract state remains unchanged.

@external
def transfer(amount: uint256):
    assert amount > 0, "Amount must be greater than zero"
    # transfer logic

We are going to use the following four examples so as to fully understand how range can be used in this manner. In both examples, the compile time constant N is 4. What changes is the stop value. The first pair has a stop value of 2 and the other has a stop value of 84.

First Pair


latest_index: public(int128)

N: constant(int128) = 4  # compile time constant

@external
def process_chunk() -> int128:
    for i in range(2, bound=N):
        self.latest_index = i
    return self.latest_index


latest_index: public(int128)

N: constant(int128) = 4  # compile time constant

@external
def process_chunk() -> int128:
    for i in range(min(2, N), bound=N):
        self.latest_index = i
    return self.latest_index

When we run the above two contracts, the latest_index value returned is 1.

Second pair


latest_index: public(int128)

N: constant(int128) = 4  # compile time constant

@external
def process_chunk() -> int128:
    for i in range(84, bound=N):
        self.latest_index = i
    return self.latest_index


latest_index: public(int128)

N: constant(int128) = 4  # compile time constant

@external
def process_chunk() -> int128:
    for i in range(min(84, N), bound=N):
        self.latest_index = i
    return self.latest_index

When we run the first contract in this pair, it throws a ContractLogicError: Execution Reverted.

However, the last contract returns a latest_index value of 3 when run.

Explanation

In the first pair of examples, we get 1 as as the returned value simply because the stop value doesn't exceed constant N.

In the second pair, we can see that we get an error where as the second example compiles well. The reason behind this is the use of min(stop, N) as an argument. It simply minimizes the stop value in respect to the value of N provided. Therefore, the minimum possible value of stop in this case will be 4 hence the returning an index value of 3.

For more information, please visit the official vyper documentation and I would also recommend my previous article for a deeper understanding of vyperlang. If you found this article helpful, i would be delighted if you gave me a heart. Follow for more. Thank you!

Mastering functions in Vyper(part2)

Muwawu Moses — Sun, 26 May 2024 16:17:24 +0000

In our previous tutorial, we clearly saw the structure of functions, function decorators and how functions can be called.

In today's lesson, we are going to see how the if--elif--else control structures could be applied in our functions. Also, this example of smart contract is going to give us more confidence of how we can use @internal and @external decorators.

@internal
def add_numbers(x: int128 = 3, y: int128 = 4 ) -> int128:
    return x + y

@internal
def multiply_numbers(x: int128 = 3, y: int128 = 4) -> int128:
    return x * y

@external
def my_choice(choice: int128) -> int128:
    if choice == 1:
        return self.add_numbers()
    elif choice == 2:
        return self.multiply_numbers()
    else:
        return 0

In the above example, we call three functions. The first two have got the @internal decorator and the last one has go the @external decorator. As we said earlier, internal functions can only be accessed by other functions within the same contract and are called using the self object. Therefore, we use the self.add_numbers to call an internal function by an external function of the same contract.

Interacting with the contract

For the purpose of this tutorial, i will use web3.py to interact locally with the smart contract we just deployed.

import sys
from web3 import Web3

# Connect to BSC node (Binance Smart Chain)
bsc_node_url = 'https://data-seed-prebsc-1-s1.binance.org:8545/'  # Replace with your BSC node URL
web3 = Web3(Web3.HTTPProvider(bsc_node_url))

# Set the private key directly (For demonstration purposes only, do not hardcode in production)
private_key = 'Your_private_key'  # Replace with your actual private key
account = web3.eth.account.from_key(private_key)

# Contract ABI
contract_abi = [Copy_and_paste_your_ABI_here]

# Contract address
contract_address = web3.to_checksum_address('Your_contract_address')  # Replace with your contract's address

# Create contract instance
contract = web3.eth.contract(address=contract_address, abi=contract_abi)


# Function to set a choice
def call_my_choice(choice):
    nonce = web3.eth.get_transaction_count(account.address)
    tx = contract.functions.my_choice(choice).build_transaction({
        'chainId': 97,  # BSC testnet
        'gas': 3000000,
        'gasPrice': web3.to_wei('5', 'gwei'),
        'nonce': nonce,
    })
    signed_tx = web3.eth.account.sign_transaction(tx, private_key)
    tx_hash = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
    receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
    result = contract.functions.my_choice(choice).call()
    return result

# Prompt user for input
def main():
    choice = int(input("Enter your choice (1 or 2): "))

    if choice in [1, 2]:
        result = call_my_choice(choice)
        print(f'Result of the calculation: {result}')
    else:
        print("Invalid choice. Please enter 1 or 2.")

if __name__ == "__main__":
    main()

Result

From the result image above, it's fully evident that our smart contract is giving the expected results. When we set the choice to 1, the answer is 7. This because the add_numbers function was called which added the default values of x and y.

When we set the choice to 2, the answer is 12. This because the multiply_numbers function was called which multiplied the default values of x and y.

For more vyper content, please follow me and like my my posts.
I will be glad for any interactions in the comment section. I am here to learn and teach. Next Tutorial

Thank you!

Mastering Vyper Functions(part1 )

Muwawu Moses — Fri, 24 May 2024 10:56:18 +0000

Definition

As defined in the vyperlang official documentation, functions are executable units of code within a contract. Functions may be called internally or externally depending on their visibility and, they may accept input arguments and return variables in order to pass values between them. Let's have a quick function structure example;

@external
def my_function():
    ...

Function visibility

It's a must that all functions must include exactly one visibility decorator i.e @internal or @external.

External functions:

These are marked with the @external decorator and are part of the contract interface and may only be called via transactions or from other contracts.

An external function may either have default or no default arguments. First,i will provide a function with no default argument.

@external
def my_function(x: uint256, b: uint256):
    pass

A function with default argument:

@external
def my_function(x: uint256, b: uint256 = 1):
    pass

For functions with default arguments, the Vyper compiler will generate N+1 overloaded function selectors based on N default arguments.

A function selector is how a vyper contract knows which function you are trying to call in the transaction.

In this example, my_function has one required argument x and one default argument b, which defaults to 1 if not provided.
Function Selectors

Because there is one default argument (b), Vyper will generate 1 + 1 = 2 function selectors:

Selector 1: For my_function(uint256 x, uint256 b)
Selector 2: For my_function(uint256 x)

Selector 1 for my_function with both arguments provided:
- This allows the function to be called with both x and b. Let's take an example where we call both arguments;

# x is set to 10
# b is explicitly set to 5
my_function(10, 5)

Selector 2 for my_function with only x provided:
- This allows the function to be called with just x, using the default value for b. And when we call only the required argument;

# x is set to 10
# b defaults to 1 (since no value for b is provided)
my_function(10)

Internal functions:

These functions are marked with the @internal decorator. They can only be accessed by other functions within the same contract and are called using the self object.

Imagine you have a contract that needs to do some repetitive calculations. Instead of writing the same code multiple times, you create an internal function to handle this. Other functions in your contract can call this internal helper whenever needed.

Example:

# an internal function that doubles a number
@internal
def _double(value: uint256) -> uint256:
    return value * 2

# an external function that users can call, which uses _double internally.
@external
def get_double(value: uint256) -> uint256:
    return self._double(value)

Well, congratulations for coming this far. I would recommend you to visit my next tutorial for more information about functions.
If you found this article helpful, please give me a heart, a follow and welcome any kind of interaction in the comment section.

Thank you!

Vyper beginner's tutorial: Variables.

Muwawu Moses — Thu, 23 May 2024 13:09:51 +0000

In our previous tutorial, we managed to write a very simple smart contract code and explained the syntax and structures involved. So now, let's extend our learning to a broader spectrum by going deep into variables.

What are Variables?

In Vyper, all variables must be explicitly declared with a type. The type of a variable determines the kind of data that it can store. For example, you can declare a variable to store an unsigned integer, a string, or a boolean value.

Variable types

In Vyper, variables can be broadly categorized into two main types based on their scope and storage:

Local Variables
State Variables

Local variables:

These are temporary variables that exist only within the scope of a function. They are not stored on the blockchain and only exist in memory during the execution of the function.

Local variables are declared within functions and the variables are only accessible within the functions they are declared in.

Examples:

To better understand how variables are declared in vyper, we shall need to use a series of examples. If you look closely in the examples we provided below, all variables are declared within the function. In the following examples, our aim is to write a smart contract function for adding two numbers:

@external
def addTwo(x: int128, y: int128) -> int128:
    result: int128 = x + y
    return result

To be more concise and idiomatic:

# a simple function to add two numbers x and y
@external
def addTwo(x: int128, y: int128) -> int128:
    return x + y

We are going to divide the above code into three parts i. e;

   @external

@external: This is a decorator that specifies the visibility of the function. It indicates that the function addTwo can be called from outside the contract. In other words, other smart contracts and external users can invoke this function. This decorator ensures that the function is part of the contract's public interface.

   def addTwo(x: int128, y: int128) -> int128:

def: This keyword is used to define a function in Vyper (similar to Python).
addTwo: This is the name of the function. It is a descriptive name indicating that the function will add two numbers.
x: int128: This declares a parameter x for the function. The type of x is int128, which means it is a signed 128-bit integer. In Vyper, specifying the type of each variable is mandatory to ensure type safety and prevent overflow/underflow errors.
- int128: This type can hold values from -2^127 to (2^127) - 1. It is used for variables that need to store integer values within this range.
y: int128: This declares another parameter y for the function. Like x, y is also of type int128.
- -> int128: This part specifies the return type of the function. It indicates that the function will return a value of type int128.

The truth is, Smart contracts on Ethereum are designed to be deterministic and do not interact with users in the same way traditional programs do. Therefore, to be able interact with our contract, we need some other tool and that is web3.py. If you don't know how to use web3.py library, please visit my tutorial here and it will be helpful.

my_contract.py file:

from web3 import Web3

# Connect to a local or remote Ethereum node
web3 = Web3(Web3.HTTPProvider('https://data-seed-prebsc-1-s1.binance.org:8545/'))  # or your Infura endpoint, etc.

# ABI of the compiled Vyper contract
abi = [
    {
        "type": "function",
        "name": "addTwo",
        "stateMutability": "nonpayable",
        "inputs": [
            {
                "name": "x",
                "type": "int128"
            },
            {
                "name": "y",
                "type": "int128"
            }
        ],
        "outputs": [
            {
                "name": "",
                "type": "int128"
            }
        ]
    }
]


# Address of the deployed contract
contract_address = web3.to_checksum_address('YOUR_CONTRACT_ADDRESS')  # replace with your contract's address

# Create a contract instance
contract = web3.eth.contract(address=contract_address, abi=abi)

# Call the addTwo function
def call_addtwo():
    try:
        x = int(input('Enter X value: '))
        y = int(input('Enter Y value: '))
        result = contract.functions.addTwo(x, y).call()
        print(f"The result of {x} + {y} is: {result}")
    except ValueError:
        print('Invalid input. Please enter valid integers for X and Y.')
    except Exception as e:
        print(f'Error during addition: {e}')

# Call the function to get user input and add the numbers
call_addtwo()

And then, run your file and you should get something similar to this:

State Variables

These are stored on the blockchain. They are part of the contract's state and are persistent across function calls and transactions.
State variables are declared outside of functions, typically at the top of the contract. They are accessible by all functions within the contract and are stored in the contract's storage. Let's have an example to better understand this:

# Define a public variable to store the greeting
greeting: public(String[100])

# Constructor to initialize the greeting
@external
def __init__():
    self.greeting = "Hello, World"

# Function to set a new greeting
@external
def set_greeting(new_greeting: String[100]):
    self.greeting = new_greeting

# Function to get the current greeting
@external
@view
def get_greeting() -> String[100]:
    return self.greeting

Here is the detailed explanation of our code:

# Define a public variable to store the greeting
greeting: public(String[100])

greeting: This is a state variable defined with the type String[100].
- State Variable: This variable is stored on the blockchain, which means its value persists across transactions.
- public: The public keyword makes this variable accessible from outside the contract, creating an automatic getter function.
- String[100]: As already mentioned in previous examples, this specifies that the variable is a string with a maximum length of 100 characters.

@external
def __init__():
    self.greeting = "Hello, World"

init(): This is the constructor function of the contract, called once when the contract is deployed.
- self.greeting = "Hello, World": This initializes the greeting state variable with the string "Hello, World".

@external
def set_greeting(new_greeting: String[100]):
    self.greeting = new_greeting

set_greeting(new_greeting: String[100]): This function allows the greeting to be updated.
- new_greeting: String[100]: The function takes one parameter, new_greeting, which must be a string with a maximum length of 100 characters.
- self.greeting = new_greeting: This updates the greeting state variable with the new value provided.

@external
@view
def get_greeting() -> String[100]:
    return self.greeting

get_greeting() -> String[100]: This function returns the current value of the greeting variable.
- @view: This is one of the available but optional decorators. It indicates that the function does not modify the state of the contract (i.e., it is a read-only function).
- return self.greeting: This returns the value of the greeting state variable.

I am very sure now you purely get the context of variables as used in vyperlang. Let's do one more last part of interacting with our smart contract using web3.py library.

Please note that in the following example, we didn't use environment variables for the sake of brevity. But, i would recommend not to expose your variables by creating a .env file for them.

import sys
from web3 import Web3

# Connect to BSC node (Binance Smart Chain)
bsc_node_url = 'https://data-seed-prebsc-1-s1.binance.org:8545/'  # Replace with your BSC node URL
web3 = Web3(Web3.HTTPProvider(bsc_node_url))

# Set the private key directly (For demonstration purposes only, do not hardcode in production)
private_key = 'YOUR_PRIVATE_KEY_HERE'  # Replace with your actual private key
account = web3.eth.account.from_key(private_key)

# Contract ABI
contract_abi = [
    {
        "type": "constructor",
        "stateMutability": "nonpayable",
        "inputs": []
    },
    {
        "type": "function",
        "name": "set_greeting",
        "stateMutability": "nonpayable",
        "inputs": [
            {
                "name": "new_greeting",
                "type": "string"
            }
        ],
        "outputs": []
    },
    {
        "type": "function",
        "name": "get_greeting",
        "stateMutability": "view",
        "inputs": [],
        "outputs": [
            {
                "name": "",
                "type": "string"
            }
        ]
    },
    {
        "type": "function",
        "name": "greeting",
        "stateMutability": "view",
        "inputs": [],
        "outputs": [
            {
                "name": "",
                "type": "string"
            }
        ]
    }
]

# Contract address
contract_address = web3.to_checksum_address('YOUR_CONTRACT_ADDRESS')  # Replace with your contract's address

# Create contract instance
contract = web3.eth.contract(address=contract_address, abi=contract_abi)

# Function to get the current greeting
def get_greeting():
    return contract.functions.get_greeting().call()

# Function to set a new greeting
def set_greeting(new_greeting):
    nonce = web3.eth.get_transaction_count(account.address)
    tx = contract.functions.set_greeting(new_greeting).build_transaction({
        'chainId': 97,  # BSC testnet
        'gas': 3000000,
        'gasPrice': web3.to_wei('5', 'gwei'),
        'nonce': nonce,
    })
    signed_tx = web3.eth.account.sign_transaction(tx, private_key)
    tx_hash = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
    receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
    return receipt

# Main execution
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python3 interact_with_greeting_contract.py <action> [<value>]")
        print("Actions: get, set")
        sys.exit(1)

    action = sys.argv[1]

    if action == "get":
        print("Current greeting:", get_greeting())
    elif action == "set":
        if len(sys.argv) < 3:
            print("Usage: python3 interact_contract.py set <value>")
            sys.exit(1)
        new_greeting = ' '.join(sys.argv[2:])
        receipt = set_greeting(new_greeting)
        print("Transaction receipt:", receipt)
    else:
        print(f"Unknown action: {action}")
        sys.exit(1)

Results

From the result image above, you can see that when we initially ran the get command, we got the expected Current greeting: Hello, World.

Then, when we go on to run the set command with the string set to "Good Morning Everyone!", we do get the same expected result when we run the get command; Current greeting: Good Morning Everyone!

You can check out my next tutorial on vyper functions.
If you found this article helpful, please give me a heart, follow and I will be happy for any interactions in the comments section. Thank you!

Vyper Beginner's tutorial: Syntax and Structure.

Muwawu Moses — Mon, 20 May 2024 13:48:29 +0000

What is Vyper?

Vyper(vyperlang) is a python-like programming language for writing smart contracts on the Ethereum blockchain just like Solidity.
It is a statically-typed language, which means that the type of each variable must be explicitly declared. This helps to prevent type-related errors and makes the code easier to read and understand.

Vyper also has a number of features that are designed to improve the security of smart contracts. For example, Vyper does not allow for low-level operations, such as direct memory access, which can be a source of vulnerabilities in smart contracts. Vyper also has built-in support for security features, such as reentrancy guards and overflow protection.

This makes Vyper a popular choice among developers whose major emphasis is on security, readability and simplicity.

During the course of this tutorial, our major emphasis is going to be on the basic syntax and structure of a vyper contract.

Prerequisites:

Basic Knowledge in Python or any other programming language.
A well set up development environment(i recommend one of my previous articles for this purpose)
And lastly, we shall need to interact with our smart contracts using web3.py( Again, i recommend my previous article for this purpose)

Well! With all the above in place, we are now good to go.

Syntax and Structure:

Just like any other programming language, vyper also has several specific syntax rules that you should be aware of. These rules help ensure code readability, security and simplicity I will advise you to visit the vyperlang official documentation for more information about the vyperlang syntax.

As you might have noticed, learning the syntax is one thing but also applying the knowledge is another. Therefore, let's use a simple smart contract example;

# A simple Vyper contract
@external
def sayHello() -> String[13]:
    return "Hello, World!"

I will start with the first line of code:

# A simple Vyper contract

This is simply a line of comment in our vyper code. Such code is ignored by the compiler and therefore, it's always meant to provide explanation to human understanding of the code.

   @external

This is a decorator that specifies that the following function is part of the public interface of the smart contract. It means that this function can be called from outside the contract, such as by other contracts or users interacting with it.

Please note that all functions must include one visibility decorator (@external or @internal). The remaining decorators are optional.

   def sayHello() -> String[13]:

def is a keyword used to define a function.
sayHello is the name of the function. You can call this function sayHello to execute the code within it.
(): The parentheses are used to list parameters if the function takes any. In this case, sayHello does not take any parameters.
-> String[13]: This part specifies the return type of the function. It indicates that the function will return a string of a maximum length of 13 characters.

   return "Hello, World!"

The function body contains the code that is executed when the function is called.

return is a keyword that specifies the value to be returned by the function.
"Hello, World!" is a string literal, and in this case, it is the value that the function returns. The length of this string is 13 characters, matching the specified return type String[13].

Conclusion

Vyper is a very secure and simple programming language meant for writing smart contracts targeting the Ethereum Virtual Machine(EVM). We meet in the next tutorial about variables If you found this post helpful, please like and share it to others. Any kind of interaction in the comment section will do me good and i am open to any kind of opinion. Thank you.

How to interact with Smart Contracts using Python and Django.

Muwawu Moses — Sat, 18 May 2024 07:20:20 +0000

In our previous article, we saw how to locally interact with smart contracts. However, this was through Vs code terminal. Now, it's time to raise the bar and interact with our smart contract through a web browser.

Prerequisites:

Prior knowledge in Django
Smart contract code already written, compiled and deployed on binance smart chain.
ABI and contract address copied and saved.
Ganache running on our local machine.

So, we are going to make a few changes in our previous set up.
First, we shall need to install django into our development environment. I will use Django 4.2 for this project.

pip install django==4.2

Next, we are going to start a django project named myproject by running:

django-admin startproject myproject

We then navigate to the root project by running:

cd myproject

Next is to start an app, add it to installed apps and then run migrations.

python3 manage.py startapp myapp, add the newly created app to installed apps and then run migrations: python3 manage.py migrate

After that, it's time to start our building process.

First, delete the previous folder vyper_project which contained our python file we used in the previous tutorial.

Navigate to the myapp directory and create there a new file called contracts.py:

# myapp/contracts.py
from web3 import Web3

# Connect to a remote bnb chain node
web3 = Web3(Web3.HTTPProvider('https://data-seed-prebsc-1-s1.binance.org:8545/'))  # or your moralis endpoint, etc.

# ABI of the compiled Vyper contract
abi = [
    {
        "type": "function",
        "name": "sayHello",
        "stateMutability": "nonpayable",
        "inputs": [],
        "outputs": [
            {
                "name": "",
                "type": "string"
            }
        ]
    }
]


# Address of the deployed contract
contract_address = web3.to_checksum_address('0xae95803315d402afb1a24c48e4c3f7d67180747e')  # replace with your contract's address

# Create a contract instance
contract = web3.eth.contract(address=contract_address, abi=abi)

# Call the sayHello function
def call_say_hello():
    try:
        result = contract.functions.sayHello().call()
        return result
    except Exception as e:
        return str(e)

Next, is to create the following files within the myapp directory.

views.py

from django.views.generic import TemplateView
from .contracts import call_say_hello

class HelloMessageView(TemplateView):
    template_name = 'myapp/hello_message.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['message'] = call_say_hello()
        return context

urls.py

# myapp/urls.py
from django.urls import path
from .views import HelloMessageView

urlpatterns = [
    path('', HelloMessageView.as_view(), name='hello_message'),
]

And lastly, create an html file in your templates folder e.g templates/myapp/hello_message.html.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Hello Message</title>
</head>
<body>
    <h1>Hello Message</h1>
    <p>{{ message }}</p>
</body>
</html>

Wow! we are now ready to run our server.

python3 manage.py runserver

The goal here is to print a Hello, World! statement from our smart contract When we open the browser on localhost: 8000, we see the following result:

This confirms that we have had a successful journey. If you found this article helpful, give me a heart and follow for more. I welcome any kind of interactions in the comment section. Thank you!

How to Interact with Smart Contracts locally using web3.py

Muwawu Moses — Fri, 17 May 2024 20:13:19 +0000

Writing smart contracts is one thing but, interacting with them is another.Today we are going to dive into how we can interact with our deployed smart contracts locally using web3.py. I would recommend you to look out for my early post which is a beginner tutorial on how to write smart contracts using vyper, remix IDE and deploying them on bnb smart chain.

Step-by-step procedure:

We are going to go through the process in two major steps i.e;

a. Writing and compiling our smart contract on remix and then deploy it on binance smart chain.

b. Interacting with the deployed smart contract locally in vs code.

Well, let's start with writing the following smart contract in Remix IDE that must print Hello, World!.

# A simple Vyper contract
@external
def sayHello() -> String[13]:
    return "Hello, World!"

I won't go deep into this process as i have already covered this in my first tutorial.. I would recommend you visit it so that we can move at the same pace.

So, after compiling, copy and save the ABI. We shall use this later with in our web3.py code.

Next, deploy the code and copy and save the contract address. This also, is going to be important in our web3.py code as we shall see later.

I am going to use vs code for development on wsl2(Ubuntu) on my local machine, and web3.py for interacting with the smart contracts.

First, we need to setup our development environment by setting up a development folder and environment.We shall do this by running the following commands in Ubuntu simultaneously as follows $ mkdir testing, $ cd testing, $ python3 -m venv .venv, and then open vs code using the command; code .

In vs code, open terminal and activate the virtual environment
by running $ source .venv/bin/activate

Next, we need to install a very important tool Ganache.This development tool allows you to simulate a blockchain environment locally on your machine.Let's run the following commands to install and activate it respectively.

$ npm install -g ganache-cli and ganache-cli.

Installing web3.py

This is a Python library for interacting with Ethereum-based blockchains. Let's install by running the following command:

$ pip install web3.

Good. Now, we are ready to go. Next, let's create a folder inside our root folder testing and name it vyper_project. Then, inside our newly created folder, we create a file named call_say_hello.py. This is where we are going to put our python code.

from web3 import Web3

# Connect to a remote bsc node
web3 = Web3(Web3.HTTPProvider('https://data-seed-prebsc-1-s1.binance.org:8545/'))

# ABI of the compiled Vyper contract
abi = [
    {
        "type": "function",
        "name": "sayHello",
        "stateMutability": "nonpayable",
        "inputs": [],
        "outputs": [
            {
                "name": "",
                "type": "string"
            }
        ]
    }
] # Replace this with your contact ABI


# Address of the deployed contract
contract_address = web3.to_checksum_address('0xae95803315d402afb1a24c48e4c3f7d67180747e')  # replace with your contract's address

# Create a contract instance
contract = web3.eth.contract(address=contract_address, abi=abi)

# Call the sayHello function
def call_say_hello():
    try:
        result = contract.functions.sayHello().call()
        print('Contract sayHello() output:', result)
    except Exception as e:
        print('Error calling sayHello():', e)

call_say_hello()

Lastly, we have to run the code.

$ python3 path/to/your/file which in this case will be $ python3 vyper_project/call_say_hello.py

We should get this out-put:

The out put of Contract sayHello output: Hello, World! confirms that we have successfully interacted with our smart contract.

Congratulations if you have made it up to this stage. Happy building.
You can also check on my article of how to interact with smart contracts using python and django.
If you found this article helpful, please leave a heart and interactions are welcome in the comment section.

Writing Smart Contracts using Vyper, Remix IDE and deploying them on BNB Smart Chain.

Muwawu Moses — Fri, 10 May 2024 14:34:54 +0000

Having had a strong background in python, I looked for the language that was fit for me to write smart contracts on the BNB Smart Chain. Since the BNB Smart Chain is compatible with the Ethereum Virtual Machine(EVM), Vyper (a pythonic smart contract programming language) was a perfect choice for me.

Without wasting time , let's dive in the building procedure.

In this tutorial, we gonna be writing a very simple smart contract code that returns "Hello World".

Requirements:

Remix IDE
MetaMask wallet chrome extension(recommended)

First, we need to setup our MetaMask wallet so as to be able deploy our smart contracts to the binance smart chain testnet.

Since we have everything properly setup, let's start the building process. Our next target is Remix IDE.

Set up Remix IDE to work with vyperlang: First, go to the plugin symbol just above settings and activate the Vyper compiler as shown below.

Create a new file named testing12.vy:

Copy and paste the following code into testing12.vy:

# A simple Vyper contract
@external
def sayHello() -> String[13]:
    return "Hello, World!"

It's time now to compile our code.

Next is deploying our compiled code to bsc.

You'll note that after pressing the deploy button, a metamask wallet window pops up requiring you to either accept or reject the transaction.

Lastly, we are going to check the status of our transaction.

First, go to BSc testnet . Here, you'll find a record of your transactions. The question is, how? Simply copy the block number from the remix IDE e.g; 40149350

and paste it into the search bar and press enter. You'll get such a result;

Closing Remarks:

Building on the Binance Smart Chain (BSC) using Vyper is an exciting journey into the world of decentralized applications (DApps). Vyper's simplicity, security and readability make it a great choice for smart contract development, especially for those who are new to blockchain programming or with a background in python. If more interested, you can check on how to interact with smart contracts locally using web3.py
Lastly, if you found this article helpful, don't forget to show your support by liking 👍 and sharing it with others who might benefit from it.
Thank You 😍

Django With Postgres On Ubuntu.

Muwawu Moses — Wed, 27 Mar 2024 13:44:40 +0000

Welcome to the world of Django with PostgreSQL on Ubuntu! In this guide, we'll embark on:

Installing postgreSQL and all requirements.
Setting up a virtual environment for our project.
Setting up project.
Integrating postgres.

Prerequisites:

Wsl2 and the latest Ubuntu(used Ubuntu 22.04) installed.
Python(version 3+) installed.

Installing postgreSQL on Ubuntu.

First, refresh your server’s local package index:

sudo apt update

Then, install the postgres package:

sudo apt install postgresql postgresql-contrib

The installation procedure created a user account called postgres that is associated with the default Postgres role. To connectc to the Postgres prompt, run the psql command as the postgres account directly with sudo:

sudo -u postgres psql

To exit:

\q

And press exit to your regular system user.
For more comprehensive information about interacting with Postgres, visit here

Setting up a virtual environment for our project.

First, update Ubuntu by running:
sudo apt update && sudo apt upgrade
Then, install venv by running:
sudo apt install python3-venv.
Create a folder(We are going to name ours Helloworld) by running the following command:
mkdir Helloworld
Inside your HelloWorld project folder, use the following command to create a virtual environment named .venv: python3 -m venv .venv.
To activate the virtual environment, enter: source .venv/bin/activate. If it worked, you should see (.venv) before the command prompt.
Open your project folder in VS Code from your Ubuntu terminal by entering: code . (the "." tells VS Code to open the current folder).
Again if need be, activate the virtual environment that you created using your Bash terminal in VS Code: source .venv/bin/activate. If it worked, you should see (.venv) before the command prompt.

Setting up project:

Install Django in the virtual environment with the command:

python3 -m pip install django

Next, run the following command to create the Django project:

django-admin startproject myproject .

Note:
Don't run migrations with out setting up a custom user model.
Now, to create a Django app, run the administrative utility's startapp command in your project folder (where manage.py resides):
Refer to this documentation for more reference.


python3 manage.py startapp myuser

Psycopg2 is a PostgreSQL adapter for Python. Install it using pip:

pip install psycopg2

Open your Django project's settings file (settings.py) and modify the DATABASES setting to use PostgreSQL:

from decouple import Config, RepositoryEnv
# Load configuration from .env file
config = Config(RepositoryEnv('.env'))

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = config('SECRET_KEY')

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = config('DEBUG', cast=bool)

DATABASES = {
       'default': {
           'ENGINE': 'django.db.backends.postgresql_psycopg2',
           'NAME': config('DB_NAME'),
           'USER': config('DB_USER'),
           'PASSWORD': config('DB_PASSWORD'),
           'HOST': config('DB_HOST'),
           'PORT': config('DB_PORT'),
    }
  }

Create a .env file in your project's root directory to store sensitive information like database credentials. Add the following entries to it:


DEBUG=True
SECRET_KEY='django-insecure-2$jm=82*r#^p0-b8+0ukno+4!a798awx53rqi!z)h*8*pojr96'

DB_NAME='mydatabase'
DB_USER='myuser'
DB_PASSWORD='your_password'
DB_HOST='localhost'
DB_PORT=''

Replace the values with the appropriate database name, username, password, host, and port.
Python Decouple allows you to manage project settings using environment variables. Install it via pip:
pip install python-decouple