DEV Community: Henry Pham

How to write NFT Marketplace Algorand

Henry Pham — Thu, 23 Nov 2023 07:36:12 +0000

Overview

NFT marketplaces are online platforms that allow creators to mint and sell their NFTs to buyers who can purchase them using cryptocurrency. These marketplaces typically provide a user-friendly interface for creating and managing NFTs, including the ability to set prices, royalties, and other terms and conditions. In this article, we will explore how to create an NFT marketplace smart contract on Algorand.

Prerequisites

Before diving into the development process, ensure you have the following tools set up:

Docker desktop
Python and pipx
Visual Studio Code
Chrome browser

Setup Project

Install Algokit

Algokit simplifies Algorand development. Install it using pipx:

pipx install algokit

Start Localnet

Launch the local Algorand network:

algokit localnet start

Init Project

Create a new project with Algokit:

algokit init

Choose TypeScript as the preferred language.

Marketplace Smart Contract

Step 1: Defining Struct

Structs organize and store essential data within the smart contract. Start by defining the collection struct to contain pertinent collection information:

type collectionData = {
  name: string;
  owner: Address;
};

Similarly, define the nftData struct to link NFTs with their respective collections:

type nftData = {
  collectionId: number,
  nftAsset: Asset,
};

Lastly, create the orderData type to manage order details within the marketplace:

type orderData = {
  owner: Address,
  price: uint64,
  nft: Asset,
  status: uint64; // 0 false 1 true
};

These structured definitions lay the foundation for organizing collection, NFT, and order-related information within the Algorand smart contract.

Step 2: Create Collection Function

Initialization:

collectionIndex is a global state key that maintains the index for collections.
collection is a box map that stores collection data based on their respective indexes.

collectionIndex = GlobalStateKey<uint64>();
collection = BoxMap<uint64, collectionData>({});

Create Collection Function:

This function creates a new collection within the smart contract.
It takes the name of the collection as a parameter and assigns the creator's address as the owner.

createCollection(name: string): void {
    const temp: collectionData = {
      name: name,
      owner: this.txn.sender,
    };

    this.collection(this.collectionIndex.value).value = temp;
    this.collectionIndex.value = this.collectionIndex.value + 1;
  }

temp stores the data for the new collection, including its name and owner (the address of the sender).
The new collection is added to the collection box map at the index specified by collectionIndex.
Increment collectionIndex to prepare for the next collection.

Step 3: Mint NFT Function

Initialization:

nft is a global state key that represents the NFT asset.

nft  =  GlobalStateKey<Asset>();

Mint NFT Function:

This function facilitates the creation of a new NFT.
It takes the name and URL of the NFT as parameters and returns the minted NFT asset.

mintNFT(name: string, url: string): Asset {
    const nftTicket = sendAssetCreation({
      configAssetTotal: 1,
      configAssetName: name,
      configAssetURL: url,
    });
    return nftTicket;
  }

nftTicket holds the newly minted NFT asset.
The sendAssetCreation function creates an NFT with the specified name and url.
It configures the NFT asset with a total supply of 1 and associates the provided metadata (name and URL) with the NFT.
Finally, the minted NFT asset is returned.

Step 4: Mapping NFT Data

Initialization:

nftIndex is a global state key used to maintain the index for NFTs.
nftDataMap is a box map that stores NFT data mapped to their respective indexes.

nftIndex  =  GlobalStateKey<uint64>();
nftDataMap  =  BoxMap<uint64, nftData>({ prefix:  'n' });

Map NFT data function:

This function maps an NFT to its associated collection.
It takes the NFT asset and the ID of the collection as parameters.

mapNFTdata(nft: Asset, collectionId: uint64): void {
    const temp: nftData = {
      collectionId: collectionId,
      nftAsset: nft,
    };

    this.nftDataMap(this.nftIndex.value).value = temp;
    this.nftIndex.value = this.nftIndex.value + 1;
  }

temp holds the data associating the NFT with its collection ID.
The nftDataMap box map stores this data at the index specified by nftIndex.
nftIndex is incremented to prepare for the next NFT mapping.

Step 5: Listing NFT to Marketplace

Initialization:

orderIndex is a global state key that maintains the index for orders in the marketplace.
order is a box map that stores order data, representing the listing details of NFTs.

orderIndex  =  GlobalStateKey<uint64>();
order  =  BoxMap<uint64, orderData>({ prefix:  'o' });

Listing NFT Function:

This function enables the listing of an NFT for sale in the marketplace.
It takes the NFT asset, sale price, and the transaction details as parameters.

listingNFT(nft: Asset, price: number, axfer: AssetTransferTxn): void {
    // verfiy Txn
    verifyTxn(axfer, { assetReceiver: this.app.address });

    // create order
    const temp: orderData = {
      owner: this.txn.sender,
      price: price,
      nft: nft,
      status: 0,
    };

    this.order(this.orderIndex.value).value = temp;
    this.orderIndex.value = this.orderIndex.value + 1;
  }

Verification is performed to ensure that the transfer transaction involves the marketplace contract as the receiver, securing the listing process.
The function creates an order for the listed NFT, capturing details such as the owner's address (this.txn.sender), the sale price, the nft being listed, and its status set as 0 indicating it's listed for sale.

Step 6: Unlisting NFT from Marketplace*

This function facilitates the removal of a listed NFT from the marketplace.
It takes the orderId of the listing and the NFT asset as parameters.

unListingNFT(orderId: number, nft: Asset): void {
    // verify owner
    assert(this.txn.sender === this.order(orderId).value.owner);

    // check Status of NFT
    assert(this.order(orderId).value.status === 1);

    this.order(orderId).value.status = 1;

    // Transfer NFT to owner
    sendAssetTransfer({
      xferAsset: nft,
      assetReceiver: this.txn.sender,
      assetAmount: 1,
    });
  }

The function ensures that only the owner of the NFT can unlist it from the marketplace (assert(this.txn.sender === this.order(orderId).value.owner)).
It verifies that the NFT is currently listed for sale (this.order(orderId).value.status === 0) before proceeding with unlisting.
If conditions are met, the status of the NFT listing is updated to indicate it's no longer available (this.order(orderId).value.status = 1).
Additionally, the function transfers the NFT asset back to its owner.

Step 7: Buy NFT Function

This function enables the purchase of an NFT listed in the marketplace.
It takes the orderId of the listing, payment transaction details (payment), and the NFT asset as parameters.

buyNFTFromMarketplace(orderId: number, payment: PayTxn, nft: Asset): void {
    // Check order status
    assert(this.order(orderId).value.status === 0);
    // Check enough money to buy
    verifyTxn(payment, {
      sender: this.txn.sender,
      amount: { greaterThan: this.order(orderId).value.price },
      receiver: this.order(orderId).value.owner,
    });

    // Transfer Asset
    sendAssetTransfer({
      xferAsset: nft,
      assetReceiver: this.txn.sender,
      assetAmount: 1,
    });
  }

The function verifies that the NFT is listed and available for purchase (assert(this.order(orderId).value.status === 0)).
It verifies the buyer's payment transaction details, ensuring the correct payment amount and receiver (verifyTxn(payment, {...})).
Upon successful verification, the NFT is transferred to the buyer's address (sendAssetTransfer) and the order status is updated to indicate it's sold.

Step 8: Write some Get Function

  getCollectionName(eventId: number): string {
    return this.collection(eventId).value.name;
  }

  getCollectionByNFT(nftIndex: number): number {
    return this.nftDataMap(nftIndex).value.collectionId;
  }

  getNFTAsset(nftIndex: number): Asset {
    return this.nftDataMap(nftIndex).value.nftAsset;
  }

  getOrderOwner(orderId: number): Address {
    return this.order(orderId).value.owner;
  }

  getOrderNFT(orderId: number): Asset {
    return this.order(orderId).value.nft;
  }

  getOrderPrice(orderId: number): number {
    return this.order(orderId).value.price;
  }

  getOrderStatus(orderId: number): number {
    return this.order(orderId).value.status;
  }

These functions retrieve specific details:

getCollectionName: Retrieves the name of a collection based on its ID.
getCollectionByNFT: Retrieves the ID of the collection associated with an NFT.
getNFTAsset: Retrieves the NFT asset based on its index.
getOrderOwner: Retrieves the owner's address of a specific order.
getOrderNFT: Retrieves the NFT asset associated with an order.
getOrderPrice: Retrieves the price of an NFT listed in an order.
getOrderStatus: Retrieves the status (listed or sold) of an order.

Conclusion

In this guide, we've detailed the step-by-step process of creating an NFT marketplace smart contract on Algorand. From defining data structures to implementing essential functionalities, such as minting NFTs, listing them for sale, and enabling purchases, we've laid the groundwork for a functional NFT marketplace within the Algorand blockchain ecosystem.

Explore the entire codebase at https://github.com/cuongpo/Algorand-NFT-Marketplace for a deeper dive into the implementation details.

In the next article, we'll delve into the crucial aspect of testing this smart contract. Thank you for taking the time to read!

Build a DAO Smart Contract in Algorand using Beaker #1

Henry Pham — Tue, 07 Nov 2023 14:58:24 +0000

Decentralized Autonomous Organizations (DAOs) have gained significant attention in the blockchain space for their ability to facilitate decentralized decision-making and governance. Algorand, a blockchain platform known for its speed and security, offers a powerful environment for creating smart contracts, including DAOs. In this article, we'll walk through a sample DAO smart contract written in PyTeal, the smart contract language for Algorand. We'll explain each part of the contract and how it works.

Step 1: Declare Variables and Initialize the Application

In this first section, we declare the necessary variables and initialize the application state.

from beaker import *
from pyteal import *

from beaker.lib.storage import BoxMapping

Define a data structure for a proposal

class proposalStruct(abi.NamedTuple):
description: abi.Field[abi.String]
vote_yes: abi.Field[abi.Uint64]
vote_no: abi.Field[abi.Uint64]
status: abi.Field[abi.String]

Define the smart contract's application state

class AppStateValue:
    memberCount = GlobalStateValue(
        stack_type=TealType.uint64,
        default=Int(0),
        descr="Number Member of DAO",
    )

    proposalCount = GlobalStateValue(
        stack_type=TealType.uint64,
        default=Int(0),
        descr="Number of Proposals"
    )

    memberDAO = LocalStateValue(
        stack_type=TealType.uint64,
        default=Int(0),
        descr="Member DAO or not",
    )

    check_voted = ReservedLocalStateValue(
        stack_type=TealType.uint64,
        max_keys=8,
        descr=("Check if a user voted in a proposal"),
    )

    proposals = BoxMapping(abi.Uint64, proposalStruct)

Create an Algorand application called "Simple DAO" with the defined state

app = (
    Application("Simple DAO", state=AppStateValue())
    .apply(unconditional_create_approval, initialize_global_state=True)
    .apply(unconditional_opt_in_approval, initialize_local_state=True)
)

We declare a data structure proposalStruct to represent a proposal, which includes a description, vote counts (yes and no), and a status field.
The AppStateValue class defines the global and local state variables required for the DAO. It includes the number of members, the number of proposals, member status, a reserved local state value to check if a user voted, and a mapping to store proposals.
We create an Algorand application named "Simple DAO" with the defined state.

Step 2: Join and Leave the DAO

Next, we define functions for joining and leaving the DAO.

Check member DAO status

@app.external
def check_member_dao(*, output: abi.Uint64) -> Expr:
    return output.set(app.state.memberDAO[Txn.sender()])

Join the DAO

@app.external
def join_dao() -> Expr:
    return Seq(
        app.state.memberDAO[Txn.sender()].set(Int(1)),
        app.state.memberCount.increment(),
    )

Leave the DAO

@app.external
def leave_dao() -> Expr:
    return Seq(
        app.state.memberDAO[Txn.sender()].set(Int(0)),
        app.state.memberCount.decrement(),
    )

check_member_dao: This function checks if the sender is a member of the DAO. If they are, it sets the output to 1; otherwise, it sets it to 0.
join_dao: This function allows a user to join the DAO. It sets their DAO membership status to 1 and increments the member count.
leave_dao: This function lets a user leave the DAO. It sets their DAO membership status to 0 and decrements the member count.

Step 3: Create Proposals

We define a function to create proposals in the DAO.

Create Proposal

@app.external
def create_proposal(descr: abi.String, *, output: proposalStruct) -> Expr:
    proposal_tuple = proposalStruct()
    proposalId = abi.Uint64()
    vote_yes = abi.Uint64()
    vote_no = abi.Uint64()
    status = abi.String()
    return Seq(
        vote_yes.set(Int(0)),
        vote_no.set(Int(0)),
        status.set("In Progress"),
        proposal_tuple.set(descr, vote_yes, vote_no, status),
        proposalId.set(app.state.proposalCount.get()),
        app.state.proposals[proposalId].set(proposal_tuple),
        app.state.proposalCount.increment(),
        app.state.proposals[proposalId].store_into(output),
    )

The create_proposal function allows a user to create a new proposal. It initializes vote counts, sets the status to "In Progress," and stores the proposal in the contract's state. The proposal's details and status are stored in the output variable.

Step 4: Check and End Proposals

We define functions to check the status of proposals and end proposals when certain conditions are met.

Check Proposal

@app.external
def check_proposal(proposalId: abi.Uint64, *, output: proposalStruct) -> Expr:
    return app.state.proposals[proposalId].store_into(output)

End Proposal when total vote > 1/2 member Count

@app.external
def end_proposal(proposalId: abi.Uint64, *, output: abi.String) -> Expr:
    proposal = proposalStruct()
    description = abi.String()
    vote_yes = abi.Uint64()
    vote_no = abi.Uint64()
    status = abi.String()
    new_status = abi.String()

    total_dao_member = app.state.memberCount.get()
    app.state.proposals[proposalId].store_into(proposal)
    description.set(proposal.description)
    vote_yes.set(proposal.vote_yes)
    vote_no.set(proposal.vote_no)
    status.set(proposal.status)

    if status != "In Progress":
        return output.set("Proposal Ended")

    if 2 * (vote_yes + vote_no) < total_dao_member:
        return output.set("Not enough votes")

    if vote_yes < vote_no:
        return Seq(
            output.set("Proposal failed"),
            new_status.set("Proposal failed"),
            proposal.set(description, vote_yes, vote_no, new_status),
            app.state.proposals[proposalId].set(proposal),
        )

    return Seq(
        output.set("Proposal succeeded"),
        new_status.set("Proposal succeeded"),
        proposal.set(description, vote_yes, vote_no, new_status),
        app.state.proposals[proposalId].set(proposal),
    )

check_proposal: This function allows users to check the details of a specific proposal.
end_proposal: Users can end a proposal using this function if it has received enough votes. The function checks the vote counts and the total number of DAO members to determine if a proposal passes or fails.

Step 5: Check Voted and Vote on Proposals

We define functions to check if a user has voted and to cast votes on proposals.

@app.external
def check_voted(proposalId: abi.Uint64, *, output: abi.Uint64) -> Expr:
    return output.set(app.state.check_voted[proposalId])

Vote Function

@app.external
def vote(proposalId: abi.Uint64, vote_choice: abi.Uint8, *, output: abi.String) -> Expr:
    proposal = proposalStruct()
    description = abi.String()
    vote_yes = abi.Uint64()
    vote_no = abi.Uint64()
    status = abi.String()
    return Seq(
        proposal.decode(app.state.proposals[proposalId].get()),
        description.set(proposal.description),
        status.set(proposal.status),
        vote_yes.set(proposal.vote_yes),
        vote_no.set(proposal.vote_no),
        If(vote_choice.get() == Int(1))
        .Then(
            vote_yes.set(vote_yes.get() + Int(1)),
        )
        .Else(
            vote_no.set(vote_no.get() + Int(1)),
        ),
        proposal.set(description, vote_yes, vote_no, status),
        app.state.proposals[proposalId].set(proposal),
        output.set("Vote Successfully"),
    )

check_voted: This function allows users to check if they have already voted on a specific proposal.
vote: Users can cast their votes on proposals using this function. It increments the vote counts accordingly and updates the proposal's status.

Now, you have a complete step-by-step guide to building and interacting with the DAO smart contract on Algorand. You can opt-in to the contract, join the DAO, create and vote on proposals, check the status of proposals, and more, based on your use case.

Check only users who have joined the DAO can create proposals and vote.
Check that users can only vote once.
How to deploy and interact with dAppflow.