SAFEMINEis in the Cryptocurrencies Industry

SAFEMINE

safemine

This article took longer than expected, and I struggled at almost every step for different reasons. But… stop crying, let's make some code =) 1. Introduction In this article, we dive into with NTFs, and because simply creating a smart contract with an NFT and deploying it is very dull and has already been partly in previous articles on this topic, I decided to complicate my life and make these same NFTs created from a bot in Telegram. web3 2. The boring part that everyone skips An NFT, or Non-Fungible Token, is a unique digital asset that represents ownership of a specific item or piece of content, such as artwork, music, videos, or other forms of creative work, using blockchain technology or, in simple words, a link to your asset (storing the asset itself on the blockchain is costly). Here are some critical aspects of NFTs: : NFTs provide a way for creators to sell digital items with a clear record of ownership. This ownership is secured and verified using blockchain technology, typically on the Ethereum blockchain. Digital Ownership : Each NFT has unique properties that cannot be replicated. This uniqueness can create scarcity, which can drive up the value of the NFT. Uniqueness and Scarcity : NFTs can often be used across different blockchain platforms and applications. This means a digital artwork tokenized as an NFT can be viewed, bought, or sold in various virtual environments and marketplaces. Interoperability : The blockchain ledger records the history of each NFT, including its creation, sale, and previous ownership. This transparency helps verify the authenticity and provenance of the digital asset. Provenance and Authenticity : NFTs can be programmed to provide ongoing royalties to their original creators. Whenever the NFT is sold to a new owner, a percentage of the sale can automatically go back to the original creator. Royalties Because it is expensive to store assets in the blockchain, and there is a strong desire to show off distributed technologies, hipsters reinvent torrents and call it IPFS. IPFS, which stands for InterPlanetary File System, is a protocol and peer-to-peer network for storing and sharing data in a distributed file system. IPFS was created to make the web faster, safer, and more open. Here are some key features and concepts associated with IPFS: : Unlike traditional centralized file storage systems, IPFS is built on a distributed network. This means files aren't stored in a single location but distributed across multiple network nodes. Decentralized and Distributed : IPFS uses content-based addressing rather than location-based addressing. Each file and piece of content on IPFS is identified by a unique fingerprint called a cryptographic hash. This ensures that users are accessing the content they requested, as the hash of the content verifies its integrity. Content Addressing : Since IPFS retrieves files from the nearest node rather than a central server, it can lead to faster download speeds and reduced load on any single server. This also makes the system more resilient to censorship and server failures. Efficient and Resilient : IPFS supports versioning and linking, which allows for the creating of complex webs of data with rich relationships and history. Versioning and Linking : IPFS has a wide range of applications, including decentralized web projects, blockchain data storage, file sharing, and as a replacement for traditional HTTP in specific scenarios. Use Cases : Its decentralized nature makes IPFS a popular choice for storing data in blockchain applications, enhancing storage capacity and access efficiency. Compatibility with Blockchain IPFS is part of a more significant movement towards a decentralized internet, where users have more control over their data and how it functions. It is often associated with decentralized technologies like blockchain and distributed ledger technology. 3. Principles of work How will our bot work? When a user sends a message or image, we check if the user added his Ethereum address. We unobtrusively ask you to add it if he hasn't added it. Otherwise, we won’t let you create an NFT. After we have an address, the user can send us an image, which will be a future NFT. When we got the image, we uploaded it into IPFS and created a metafile with information about NFT. This file will be uploaded into IPFS. After we upload everything, we mint NFT in the contract with a link to a metadata file. Say, user, that's all done. … Profit 4. Prerequisites First, we need an account on Telegram Second, create a bot using @BotFather Init app with next app (not that it's essential, and you can use express, but I make some space for the future) npx create-next-app@latest telegram-bot --use-npm Go to folder cd telegram-bot And init hardhat npx hardhat init And we have a basis for our project.. So clean and nice Create file and add into it .env NEXT_TELEGRAM_TOKEN=6440257800:AAGY...
NEXT_SEED=qwerty
NEXT_VERIFIER_ADDRESS=
NEXT_NFT_ADDRESS=
NEXT_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
NEXT_JSON_RPC=http://127.0.0.1:8545/
NEXT_CHAIN_ID=1337
NEXT_IPFS_NODE=http://127.0.0.1:5001/ Here is the credential for local development. can be taken from @BotFather NEXT_TELEGRAM_TOKEN 5. Contracts 5.1 Verification Here is a simple key-value storage Create file with the following content contracts/Verification.sol // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;

// Uncomment this line to use console.log
// import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract Verification is Ownable {
    mapping(uint => address) public verified;

    constructor() Ownable(msg.sender) {}

    function verify(uint256 _id, address _address) public onlyOwner {
        verified[_id] = _address;
    }
} and scripts/deploy_verification.js const hre = require("hardhat");

async function main() {
  const instance = await hre.ethers.deployContract("Verification");
  await instance.waitForDeployment();
  console.log(`Verification Contract deployed to ${await instance.getAddress()}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});4.2 Nft Deploy it npx hardhat run scripts/deploy_verification.js --network local Save contract address into file .env ...
NEXT_VERIFIER_ADDRESS=...
... 5.2 NFT And here I decided not to bother and created a file through the wizard . It’s very convenient, but first, I would still recommend that you practice writing such contracts yourself. https://docs.openzeppelin.com/contracts/5.x/wizard Create file with the following content. contracts/TelegramBot.sol // SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract TelegramBot is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
    uint256 private _nextTokenId;

    constructor(address initialOwner)
    ERC721("TelegramBot", "TGB")
    Ownable(initialOwner)
    {}

    function safeMint(address to, string memory uri) public onlyOwner {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }

    // The following functions are overrides required by Solidity.

    function _update(address to, uint256 tokenId, address auth)
    internal
    override(ERC721, ERC721Enumerable)
    returns (address)
    {
        return super._update(to, tokenId, auth);
    }

    function _increaseBalance(address account, uint128 value)
    internal
    override(ERC721, ERC721Enumerable)
    {
        super._increaseBalance(account, value);
    }

    function tokenURI(uint256 tokenId)
    public
    view
    override(ERC721, ERC721URIStorage)
    returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
    public
    view
    override(ERC721, ERC721Enumerable, ERC721URIStorage)
    returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
} and scripts/deploy_nft.js const hre = require("hardhat");

async function main() {
  const signers = await hre.ethers.getSigners();
  console.log("Deploying contracts with the account:", signers[0].address);

  const instance = await hre.ethers.deployContract("TelegramBot", [
    signers[0].address,
  ]);
  await instance.waitForDeployment();
  console.log(`TelegramBot Contract deployed to ${await instance.getAddress()}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
}); Deploy it npx hardhat run scripts/deploy_nft.js --network local Save the contract address into file .env ...
NEXT_NFT_ADDRESS=...
... 6. Telegram webhook For local testing, I strongly recommend you to use ngrok 6.1 Preparement. Create with the following content. app/api/telegram/route.ts import { TelegramRequest } from "@/app/types";
import { ok } from "@/app/helpers/ok";

export async function POST(request: Request) {
  const reqData = (await request.json()) as TelegramRequest;
  console.log(reqData);

  return ok();
} app/helpers/ok.ts import { NextResponse } from "next/server";

export function ok() {
  return new NextResponse("Ok", {
    status: 200,
    statusText: "Ok",
    headers: {
      "Content-Type": "text/plain",
    },
  });
} helpers for interact with Telegram: app/helpers/tg.ts const sendMessageUrl = `https://api.telegram.org/bot${process.env.NEXT_TELEGRAM_TOKEN}/sendMessage`;
const fileUrl = `https://api.telegram.org/bot${process.env.NEXT_TELEGRAM_TOKEN}/getFile?file_id=`;
const downloadFileUrl = `https://api.telegram.org/file/bot${process.env.NEXT_TELEGRAM_TOKEN}/`;

export async function sendMessage(chat_id: String | number, message: String) {
  const req = await fetch(sendMessageUrl, {
    method: "POST",
    body: JSON.stringify({
      chat_id: chat_id,
      text: message,
      parse_mode: "markdown",
    }),
    headers: {
      "Content-Type": "application/json",
    },
  });

  const resp = await req.json();

  console.log("sendMessage", resp);

  return resp;
}

export async function getFile(file_id: String) {
  const req = await fetch(`${fileUrl}${file_id}`, {
    method: "GET",
  });

  const resp = await req.json();

  console.log("getFile", resp);

  return resp;
}

export async function downloadFile(file_path: String) {
  const req = await fetch(`${downloadFileUrl}${file_path}`, {
    method: "GET",
  });

  return await req.blob();
} Helpers for interact with IPFS: app/helpers/ipfs.ts export async function uploadFile(
  filename: string,
  data: Blob,
): Promise<{ Name: string; Hash: string; Size: string }> {
  const form = new FormData();
  form.append(filename, data, filename);

  const uploadResponse = await fetch(
    `${process.env.NEXT_IPFS_NODE}api/v0/add?pin=true`,
    {
      method: "POST",
      body: form,
      headers: {
        "accept-type": "application/json",
      },
    },
  );

  const resp = await uploadResponse.json();
  console.log(`upload ${filename} response:`, resp);

  return resp;
} app/types.ts export type TelegramPhotoRequest = {
  file_id: string;
  file_unique_id: string;
  file_size: number;
  width: number;
  height: number;
};

export type TelegramEntityRequest = {
  offset: number;
  length: number;
  type: string;
};

export type TelegramRequest = {
  update_id: number;
  message: {
    message_id: number;
    from: {
      id: number;
      is_bot: boolean;
      first_name: string;
      last_name: string;
      username: string;
      language_code: string;
      is_premium: boolean;
    };
    chat: {
      id: number;
      first_name: string;
      last_name: string;
      username: string;
      type: string;
    };
    date: number;
    text: string;
    photo: TelegramPhotoRequest[] | undefined;
    entities: TelegramEntityRequest[] | undefined;
    caption: string | undefined;
  };
}; Next steps will be in file app/api/telegram/route.ts 6.2 Initialise provider for work with Ethereum network. import { ethers, JsonRpcProvider } from "ethers";
import { TelegramRequest } from "@/app/types";
import { ok } from "@/app/helpers/ok";

export async function POST(request: Request) {
  const reqData = (await request.json()) as TelegramRequest;
  console.log(reqData);

  const provider = new JsonRpcProvider();
  const signer = new ethers.Wallet(
    process.env.NEXT_PRIVATE_KEY as string,
    provider,
  );

  return ok();
} 6.3 Initialise verification contract ...

const verifierAbi =
  require("@/artifacts/contracts/Verification.sol/Verification.json").abi;

export async function POST(request: Request) {
  ... 
  const verifierContract = new ethers.Contract(
    process.env.NEXT_VERIFIER_ADDRESS as string,
    verifierAbi,
    signer,
  );

  return ok();
} 6.4 Check user is registered. We need to make a hash of the user ID to preserve his anonymity. As we already know, the blockchain remembers everything, and it will not be very good for the user if we store in clear form a link between the user’s account and his telegram identifier. ...
import * as crypto from "crypto";
...

export async function POST(request: Request) {

	...

  const hash = crypto
    .createHash("sha256")
    .update(`${process.env.NEXT_SEED}:${reqData.message.from.id}`)
    .digest();

  let address = null;

  try {
    address = await verifierContract.verified("0x" + hash.toString("hex"));
  } catch (e) {
    console.log("address", e);
  }

	if (!address || address === "0x0000000000000000000000000000000000000000") {
	
	}

  return ok();
} 6.5 Registration. If the user is not registered yet, we check the message. If it is the correct address - make registration; otherwise, send a message that we need his address. ...
import { isAddress } from "ethers";
import { ok } from "@/app/helpers/ok";
import { sendMessage } from "@/app/helpers/tg";
...

export async function POST(request: Request) {
  ...

  if (!address || address === "0x0000000000000000000000000000000000000000") {
    if (isAddress(reqData.message.text)) {
      let r = await verifierContract.verify(
        "0x" + hash.toString("hex"),
        reqData.message.text.trim(),
      );
      console.log("resp", r);

      let address = await verifierContract.verified(
        "0x" + hash.toString("hex"),
      );

      const resp = await sendMessage(
        reqData.message.chat.id,
        `${address} registered\n now you can send NFTs`,
      );
      console.log("resp 1", resp);
      return ok();
    }

    const resp = await sendMessage(reqData.message.chat.id, "need authorize");
    console.log("resp 2", resp);
    return ok();
  }

  return ok();
} 6.6 Validate photo. If user doesn’t sent to us a photo, we need to talk about it ...

export async function POST(request: Request) {
  ...

  if (!reqData.message.photo) {
    const resp = await sendMessage(reqData.message.chat.id, `not found photos`);
    console.log("resp validate", resp);
    return ok();
  }
  return ok();
} 6.7 Download photo. If all checks are passed, download the sent photo import { downloadFile, getFile } from "@/app/helpers/tg";

export async function POST(request: Request) {
  ...
  let photo = reqData.message.photo[reqData.message.photo.length - 1];

  let file = await getFile(photo.file_id);
  console.log("file", file);

  let data = await downloadFile(file.result.file_path);

  return ok();
} 6.8 Save to IPFS. ...
import { uploadFile } from "@/app/helpers/ipfs";
...
export async function POST(request: Request) {
  ...
  const respNft = await uploadFile("image", data);
  console.log("respNft", respNft);

  const respMetadata = await uploadFile(
    "metadata.json",
    new Blob(
      [
        JSON.stringify({
          name: reqData.message.caption,
          image: `ipfs://${respNft.Hash}`,
        }),
      ],
      { type: "application/json" },
    ),
  );

  return ok();
} 6.9 mint users NFT. After we save all data into IPFS, we can mint NFT. const nftAbi =
  require("@/artifacts/contracts/TelegramBot.sol/TelegramBot.json").abi;

export async function POST(request: Request) {
  ...

  const nftContract = new ethers.Contract(
    process.env.NEXT_NFT_ADDRESS as string,
    nftAbi,
    signer,
  );

  const mint = await nftContract.safeMint(
    address,
    `ipfs://${respMetadata.Hash}`,
  );

  console.log("mint", mint);

  const respMint = await sendMessage(
    reqData.message.chat.id,
    `tx hash: ${mint.tx_hash}`,
  );
  console.log("resp mint", respMint);

  return ok();
} Done =) 7. Conclusion This is the simplest possible implementation, which has some usability problems but is enough to understand the principles of operation. There are plans to make a web version using Metamask, which NEXT was used for. I tried not to use libraries to communicate with Telegram and IPFS so that there would be more understanding of how it works and you can install the library very quickly. I hope this will be enough to understand the principles of operation. The source code is on . GitHub

Dive into Web3 Contracts with Hardhat and Node.js Vol.3 

How to Build a Web3 NFT Cross-Breeding Dapp with React, Solidity, and CometChat

A popular and practical use case for NFTs is generating tickets to live events. Blockchains such as can the ownership, originator, and authenticity of a digital item, effectively solving the problem of counterfeit tickets. While major players such as struggle to mitigate scalpers (trying desperately to control who can resell tickets, where, and for how much) and ticket fraud— already has a solution. The ticketing industry is ripe for disruption. Ethereum guarantee Ticketmaster web3 In this tutorial, we’ll look at how to create such a ticketing solution using ConsenSys , , and the Infura We’ll deploy a smart contract that acts as a ticketing service and creates tickets as ERC-20 non-fungible tokens (NFTs). We’ll also walk through a few architectures of potential frontends that could interface with the contract, and together function as an integrated, full-stack, web3 ticketing system. Truffle Infura NFT API. Let’s get building! Create an NFT ticketing system on Ethereum The basic architecture of our system is intended to create a smart contract that issues our tickets as non-fungible tokens (NFTs). NFTs are for what we want to build. They are provably unique digital tokens that allow us to ensure that every ticket is unique and cannot be copied or forged. This not only guarantees a secure ticketing experience for concertgoers, but also empowers artists (and event organizers) with greater control over ticket distribution, pricing, and resale. Using smart contracts and NFTs even allows for new revenue streams such as royalty payments and revenue sharing! perfect (If you need background info on any of these terms, blockchain technology, or web3 in general, check out this article on k). Learning to Become a Web3 Developer by Exploring the Web3 Stac Step 1: Install MetaMask The first thing we’re going to do is set up a MetaMask wallet and add the Sepolia test network to it. MetaMask is the world’s most popular, secure, and easy to use self-custodial digital wallet. First, . After you install the extension, MetaMask will set up the wallet for you. In the process, you will be given a secret phrase. download the MetaMask extension Keep that safe, and under no circumstances should you make it public. Once you’ve set up MetaMask, click on the Network tab on the top-right. You will see an option to show/hide test networks. Once you turn test networks on, you should be able to see the Sepolia test network in the drop-down menu. We want to use the Sepolia network so that we can deploy and test our system without spending any real money. Step 2: Get some test ETH In order to deploy our smart contract and interact with it, we will require some free test ETH. You can obtain free Sepolia ETH from the . Sepolia faucet Once you fund your wallet, you should see a non-zero balance when you switch to the Sepolia test network on MetaMask. Step 3: Install NPM and Node Like all Ethereum dapps, we will build our project using node and npm. In case you don't have these installed on your local machine, you can do so . here To ensure everything is working correctly, run the following command: $ node -v If all goes well, you should see a version number for Node. Step 4: Sign up for an Infura account In order to deploy our contract to the Sepolia network, we will need an Infura account. Infura gives us access to RPC endpoints which allow for fast, reliable, and easy access to the blockchain of our choice. . Once you’ve created your account, navigate to the and select . Sign up for a free account dashboard Create New Key For network, choose and name it , or something of your choosing. Web3 API Ticketing System Once you click on , Infura will generate an API key for you and give you RPC endpoints to Ethereum, Goerli, Sepolia, L2s, and non-EVM L1s (and their corresponding testnets) automatically. Create For this tutorial, we are only interested in the Sepolia RPC endpoint. This URL is of the form https://sepolia.infura.io/v3/←API KEY→ Step 5: Create a Node project and install necessary packages Let's set up an empty project repository by running the following commands: $ mkdir nft-ticketing && cd nft-ticketing
$ npm init -y We will be using Truffle, a world-class development environment and testing framework for EVM smart contracts, to build and deploy our cryptocurrency smart contract. Install Truffle by running: $ npm install —save truffle We can now create a barebones Truffle project by running the following command: $ npx truffle init To check if everything works properly, run: $ npx truffle test We now have Truffle successfully configured. Let us next install the contracts package. This package will give us access to the ERC-721 base implementation (the standard for non-fungible tokens) as well as a few helpful additional functionalities. OpenZeppelin $ npm install @openzeppelin/contracts To allow Truffle to use our MetaMask wallet, sign transactions, and pay gas on our behalf, we will require another package called . Install it by using the following command: hdwalletprovider $ npm install @truffle/hdwallet-provider Finally, in order to keep our sensitive wallet information safe, we will use the package. dotenv $ npm install dotenv Step 6: Create the ticketing smart contract for the NFT Open the project repository in a code editor (for example: VS Code). In the folder, create a new file called . contracts NftTicketing.sol Our ticketing contract will inherit all functionality offered by the implementation of OpenZeppelin. This includes transfers, metadata tracking, ownership data, etc. ERC721Enumerable We will implement the following features from scratch: : Our contract will give its owner the power to sell tickets at a particular price. The owner will have the power to open and close sales, update ticket prices, and withdraw any money sent to the contract for ticket purchases. The public will have the opportunity to mint tickets at sale price whenever the sale is open and tickets are still in supply. Public Primary Sale : The owner will be able to airdrop tickets to a list of wallet addresses. Airdropping : The owner will also be able to reserve tickets for himself/herself without having to pay the public sale price. Reservation Add the following code to . NftTicketing.sol //SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract NftTicketing is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable  {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIds;

    // Total number of tickets available for the event
    uint public constant MAX_SUPPLY = 10000;

    // Number of tickets you can book at a time; prevents spamming
    uint public constant MAX_PER_MINT = 5;

    string public baseTokenURI;

    // Price of a single ticket
    uint public price = 0.05 ether;

    // Flag to turn sales on and off
    bool public saleIsActive = false;

    // Give collection a name and a ticker
    constructor() ERC721("My NFT Tickets", "MNT") {}

    // Generate NFT metadata
    function generateMetadata(uint tokenId) public pure returns (string memory) {
        string memory svg = string(abi.encodePacked(
            "<svg xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='xMinyMin meet' viewBox='0 0 350 350'>",
            "<style>.base { fill: white; font-family: serif; font-size: 25px; }</style>",
            "<rect width='100%' height='100%' fill='red' />",
            "<text x='50%' y='40%' class='base' dominant-baseline='middle' text-anchor='middle'>",
            "<tspan y='50%' x='50%'>NFT Ticket #",
            Strings.toString(tokenId),
            "</tspan></text></svg>"
        ));

        string memory json = Base64.encode(
            bytes(
                string(
                    abi.encodePacked(
                        '{"name": "NFT Ticket #',
                        Strings.toString(tokenId),
                        '", "description": "A ticket that gives you access to a cool event!", "image": "data:image/svg+xml;base64,',
                        Base64.encode(bytes(svg)),
                        '", "attributes": [{"trait_type": "Type", "value": "Base Ticket"}]}'
                    )
                )
            )
        );

        string memory metadata = string(
            abi.encodePacked("data:application/json;base64,", json)
        );
        return metadata;
    }

    // Reserve tickets to creator wallet
    function reserveNfts(uint _count) public onlyOwner {
        uint nextId = _tokenIds.current();

        require(nextId + _count < MAX_SUPPLY, "Not enough NFTs left to reserve");

        for (uint i = 0; i < _count; i++) {
            string memory metadata = generateMetadata(nextId + i);
            _mintSingleNft(msg.sender, metadata);
        }
    }

    // Airdrop NFTs
    function airDropNfts(address[] calldata _wAddresses) public onlyOwner {
        uint nextId = _tokenIds.current();
        uint count = _wAddresses.length;

        require(nextId + count < MAX_SUPPLY, "Not enough NFTs left to reserve");

        for (uint i = 0; i < count; i++) {
            string memory metadata = generateMetadata(nextId + i);
            _mintSingleNft(_wAddresses[i], metadata);
        }
    }

    // Set Sale state
    function setSaleState(bool _activeState) public onlyOwner {
        saleIsActive = _activeState;
    }

    // Allow public to mint NFTs
    function mintNfts(uint _count) public payable {

        uint nextId = _tokenIds.current();

        require(nextId + _count < MAX_SUPPLY, "Not enough NFT tickets left!");
        require(_count > 0 && _count <= MAX_PER_MINT, "Cannot mint specified number of NFT tickets.");
        require(saleIsActive, "Sale is not currently active!");
        require(msg.value >= price * _count, "Not enough ether to purchase NFTs.");

        for (uint i = 0; i < _count; i++) {
            string memory metadata = generateMetadata(nextId + i);
            _mintSingleNft(msg.sender, metadata);
        }
    }

    // Mint a single NFT ticket
    function _mintSingleNft(address _wAddress, string memory _tokenURI) private {
        // Sanity check for absolute worst case scenario
        require(totalSupply() == _tokenIds.current(), "Indexing has broken down!");
        uint newTokenID = _tokenIds.current();
        _safeMint(_wAddress, newTokenID);
        _setTokenURI(newTokenID, _tokenURI);
        _tokenIds.increment();
    }

    // Update price
    function updatePrice(uint _newPrice) public onlyOwner {
        price = _newPrice;
    }

    // Withdraw ether
    function withdraw() public payable onlyOwner {
        uint balance = address(this).balance;
        require(balance > 0, "No ether left to withdraw");

        (bool success, ) = (msg.sender).call{value: balance}("");
        require(success, "Transfer failed.");
    }

    // Get tokens of an owner
    function tokensOfOwner(address _owner) external view returns (uint[] memory) {

        uint tokenCount = balanceOf(_owner);
        uint[] memory tokensId = new uint256[](tokenCount);

        for (uint i = 0; i < tokenCount; i++) {
            tokensId[i] = tokenOfOwnerByIndex(_owner, i);
        }
        return tokensId;
    }

    // The following functions are overrides required by Solidity.
    function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
        internal
        override(ERC721, ERC721Enumerable)
    {
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
    }

    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
        super._burn(tokenId);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
} Make sure the contract is compiling correctly by running: npx truffle compile Our contract is pretty complex already, but it is possible to add some extra features as you see fit. For example, you can implement an anti-scalping mechanism within your contract. The steps to do so would be as follows: Define a Solidity mapping that acts as an allowlist for wallets that can hold more than one ticket. Create a function that allows the owner to add addresses to this allowlist. Introduce a check in _ that allows mint or transfer to a wallet already holding a ticket only if it is in the allowlist. beforeTokenTransfer Add the following snippet below the contract’s constructor: mapping(address => bool) canMintMultiple;

    // Function that allowlists addresses to hold multiple NFTs.
    function addToAllowlist(address[] calldata _wAddresses) public onlyOwner {
        for (uint i = 0; i < _wAddresses.length; i++) {
            canMintMultiple[_wAddresses[i]] = true;
        }
    } Finally, modify the _ function to the following: beforeTokenTranfer // The following functions are overrides required by Solidity.
    function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
        internal
        override(ERC721, ERC721Enumerable)
    {
        if (balanceOf(to) > 0) {
            require(to == owner() || canMintMultiple[to], "Not authorized to hold more than one ticket");
        }
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
    } Compile the contract once again using the Truffle command above. Step 7: Update Truffle config and create a .env file Create a new file in the project’s root directory called and add the following contents: .env INFURA_API_KEY = "https://sepolia.infura.io/v3/<Your-API-Key>"
MNEMONIC = "<Your-MetaMask-Secret-Recovery-Phrase>" Next, let’s add information about our wallet, the Infura RPC endpoint, and the Sepolia network to our Truffle config file. Replace the contents of with the following: truffle.config.js require('dotenv').config();
const HDWalletProvider = require('@truffle/hdwallet-provider');
const { INFURA_API_KEY, MNEMONIC } = process.env;

module.exports = {
  networks: {
    development: {
      host: "127.0.0.1",
      port: 8545,
      network_id: "*"
    },
    sepolia: {
      provider: () => new HDWalletProvider(MNEMONIC, INFURA_API_KEY),
      network_id: '5',
    }
  }
}; Step 8: Deploy the NFT Smart Contract Let us now write a script to deploy our contract to the Sepolia blockchain. In the folder, create a new file called and add the following code: migrations 1_deploy_contract.js // Get instance of the NFT contract
const nftContract = artifacts.require("NftTicketing");

module.exports = async function (deployer) {
    // Deploy the contract
    await deployer.deploy(nftContract);
    const contract = await nftContract.deployed();

    // Mint 5 tickets
    await contract.reserveNfts(5);
    console.log("5 NFT Tickets have been minted!")
}; We’re all set! Deploy the contract by running the following command: truffle migrate --network sepolia If all goes well, you should see output (containing the contract address) that looks something like this: Starting migrations...
======================
> Network name:    'sepolia'
> Network id:      5
> Block gas limit: 30000000 (0x1c9c380)


1_deploy_contract.js
====================

   Deploying 'NftTicketing'
   -----------------------
   > transaction hash:    …
   > Blocks: 2            Seconds: 23
    …
   > Saving artifacts
   -------------------------------------
   > Total cost:     0.1201 ETH
Summary
=======
> Total deployments:   1
> Final cost:          0.1201 ETH You can search for your contract address on Sepolia etherscan and see it live. Congratulations! You’ve successfully deployed the contract to Sepolia. Step 9: Interface with the smart contract We have our smart contract! The next step is to deploy frontends that interface with the contract and allow anyone to call the mint function to make a donation and mint a ticket for themselves. For a fully functional ticketing service, you would typically need the following frontends: A website (with a great user experience) where public users can pay and mint their tickets. An admin portal where the owner can reserve and airdrop tickets, update pricing, transfer admin role to another wallet, withdraw sales revenue, open and close sale, etc. A tool which verifies that a person has a particular ticket both online and IRL. Building these systems from scratch is out of scope for this tutorial, but we will leave you with a few resources and tips. For the frontend minting website, check out the frontend I built in the tutorial as a starting point. Thank You NFT If you verify your contract on Etherscan, it will automatically give you an admin portal where you can call any function on your contract. This is a good first step before you decide on building a custom solution. Verifying that a wallet has a ticket from your collection is extremely simple using the function. If someone can prove that they own a wallet containing one of our tickets, it’s basically proof that they have a ticket. This can be achieved using digital signatures. balanceOf Verification using the Infura NFT API One more hint: once you have your smart contract and frontend (or even before your frontend is complete and you want to prove out that everything works), you can use the to verify that your new NFT exists. The Infura NFT API is a quick way to replace a lot of NFT-related code with a single API call. Infura NFT API For example, the information we need to show ownership of our NFT is easily available to us through the API. All we need to supply is the wallet address. The code would look something like this: const walletAddress = <your wallet address>
const chainId = "1"

const baseUrl = "https://nft.api.infura.io"
const url = `${baseUrl}/networks/${chainId}/accounts/${walletAddress}/assets/nfts`

// API request
const config = {
    method: 'get',
    url: url,
    auth: {
        username: '<-- INFURA_API_KEY –>',
        password: '<-- INFURA_API_SECRET –>',
    }
};

// API Request
axios(config)
    .then(response => {
        console.log(response['data'])
    })
    .catch(error => console.log('error', error)); Run it … $ node <filename>.js And you should see something like this: {
  total: 1,
  pageNumber: 1,
  pageSize: 100,
  network: 'ETHEREUM',
  account: <account address>,
  cursor: null,
  assets: [
    {
      contract: <NFT contract address>,
      tokenId: '0',
      supply: '1',
      type: 'ERC20',
      metadata: [Object]
    },
   …
  ]
} Conclusion In this tutorial, we deployed a fully functional NFT ticketing service using , , and the Infura . Truffle Infura NFT API It’s obviously not you would need to disrupt Ticketmaster—but it’s a solid start and a great proof of concept! Even if you don’t take this code and start your own NFT ticketing platform, hopefully you’ve learned a little about web3 in the process. everything The lead image for this article was generated by HackerNoon's via the prompt "a rock concert in a big stadium". AI Image Generator

Let's Disrupt Ticketmaster by Building a Web3 Ticketing System

With the rise of NFTs on the Ethereum blockchain, creators can now monetize their digital art, music, videos, and other media in ways previously considered impossible. However, with the ownership and transfer of NFTs comes the question of royalties when creators receive payments for subsequent sales of their work. In this article, we will explore the concept of royalties in NFTs on Ethereum and how they are changing the landscape of digital ownership and creation. The NFT royalty standard The ERC-2981, also known as the NFT Royalty Standard, is a proposal for a new Ethereum token standard that addresses this need. By implementing ERC-2981, creators can receive a percentage of each subsequent sale of their NFTs on the secondary market. It outlines rules for how royalty payments are calculated and transferred automatically to the creator's wallet whenever their NFT is resold on the secondary market. Implementing ERC-2981 would provide a transparent and efficient way for creators to receive a fair share of the profits from their NFTs, regardless of how many times they are resold. OpenZeppelin NFT royalties implementation OpenZeppelin is a widely recognized leader in the blockchain industry, and its Royalties Standard for NFTs builds on ERC-2981 to provide an even more comprehensive solution for tracking and distributing royalties. With OpenZeppelin's Royalties Standard, creators can rest assured that they are fairly compensated for their work and have greater control over how their creations are sold and distributed. There are other implementations, or we can create our own according to the ERC-2981 standard, but that is out of the scope of this article. Using the NFT royalty standard ERC721Royalty extension is one of the many extensions OpenZeppelin provides, which adds a royalty payment mechanism to the ERC721 token standard. The ERC721Royalty extension adds a new function to the ERC721 standard called for a specific NFT or for all the NFTs. This function allows a creator of an NFT to set a percentage of each sale that will be paid as a royalty to them. _setTokenRoyalty _setDefaultRoyalty The royalty payment is automatically deducted from the sale price of the NFT and transferred to a creator. To use the extension, we must inherit our NFT smart contract from the and either set royalty. Let's check out both ways, setting it for all the NFTs and specific ones. ERC721Royalty ERC721Royalty import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";

contract Royalties is ERC721Royalty {
// ...
} Setting royalties per NFT To set the royalties fee per specific NFT, we need to use the function while minting the NFT. We need to provide the royalty-received address and fee numerator. The fee numerator is a percentage. For example, if an NFT is sold for 1 ETH and the royalty fee is set to 10%, the original creator would receive 0.1 ETH for that deal. If an NFT is sold for 2 ETH the next time, the original creator will receive another 0.2 ETH for that next deal, and so on, every time that NFT is sold in the future. _setTokenRoyalty function safeMint(
  address to, 
  uint256 tokenId, 
  address receiver, 
  uint96 feeNumerator
) public {
  _safeMint(to, tokenId);

  _setTokenRoyalty(tokenId, receiver, feeNumerator);
} Now when minting an NFT, we can provide these values. For the fee numerator, we are specifying it as a percentage without a coma. It means that is equivalent to . 1000 10% Now receiver will receive 10% from each resale on NFT marketplaces like OpenSea or Rarible. Setting royalties for all NFTs The most straightforward way to specify a royalty fee is to configure that for all the NFTs equally. To do that, we can call the function when deploying the smart contract. We must provide the royalty fee receiver and fee numerator similar to what we did per each NFT. _setDefaultRoyalty constructor(address _receiver, uint96 feeNumerator) 
  ERC721("Royalties", "RYLT") {
  _setDefaultRoyalty(_receiver, feeNumerator);
} Now, all the NFT resales on marketplaces will require a royalty fee of 10% to be transferred to a creator. TL;DR The NFT royalties enable creators to earn royalties on the secondary market sales of their NFTs, similar to how artists and musicians receive royalties when their work is resold. ERC-2981 is a standard for NFTs that specifies how creators of NFTs can receive a percentage of any future sales or transfers of their NFTs. The OpenZeppelin ERC721Royalty extension makes adding royalty functionality to your NFTs smart contracts easy. Links Sample code ERC-2981: NFT Royalty Standard The ERC-2981 implementation by OpenZeppelin

Implementing the ERC-2981 NFT royalty standard with Solidity

How to Create an NFT (Digital Collectible) for Thanking Fans

How to Build a Profitable NFT Marketplace with React, Solidity, and CometChat

Cómo construir un mercado de NFT rentable con React, Solidity y CometChat

Comment créer un marché NFT rentable avec React, Solidity et CometChat

रिएक्ट, सॉलिडिटी और कॉमेटचैट के साथ एक लाभदायक एनएफटी मार्केटप्लेस कैसे बनाएं

React、Solidity、CometChat で収益性の高い NFT マーケットプレイスを構築する方法

Como construir um mercado NFT lucrativo com React, Solidity e CometChat

Cách xây dựng thị trường NFT có lợi nhuận với React, Solidity và CometChat

如何使用 React、Solidity 和 CometChat 构建盈利的 NFT 市场

Adding DAO Governance to Existing Token Contracts

Adición de la gobernanza de DAO a los contratos de token existentes

GitHub Repo:- https://github.com/PradhumnaPancholi/Figbot Hey everyone! A little while ago, I was learning as it has fantastic tools for developing and auditing smart contracts. And although I loved the experience, I soon learned that it is in the clandestine development stage. This means that casual/individual users can not depend on maintainers for support and updates. Dapp Tools Then I stumbled upon . It has everything that Dapp Tools offers apart from built-in symbolic execution (which is not a problem for me as I use e by Trail of Bits ). And this is auditing related hence not a hindrance in smart contract development by any stretch of the imagination. Foundry Manticor After working with Foundry for a bit, I enjoyed the experience and wanted to share that with others. Hence, this article. This article will go through the benefits of Foundry, the installation process,  developing an NFT (because everyone is interested in that), testing the contract, and deploying it with . Figment Datahub Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust. Foundry is made up of three components: Ethereum testing framework (like Truffle, Hardhat, and Dapptools). Forge: Swiss army knife for interacting with EVM smart contracts, sending transactions, and getting chain data. Cast: local Ethereum node, akin to Ganache, Hardhat Network Anvil: Today’s focus is going to be on But I will be posting in-depth articles on Caste and Anvil in the upcoming weeks. Forge. Why Foundry: There are many smart contract development tools like Truffle, Hardhat, and Brownie. But one of my primary reasons for looking into Dapp Tools in  the first place was native Solidity tests. Writing smart contracts is not hard when switching between frameworks like Hardhat and Brownie. And they are incredible tools with plugins, but one needs to be well versed in JavaScript/TypeScript and Python to perform testing. Foundry allows us to write our tests natively in Solidity. This saves a lot of time onboarding new developers and makes the process smoother. In my experience of helping people navigate their way into smart contracts development, I have learned that the best and most efficient way for junior developers to engage with DAO/community-maintained projects is by writing tests and learning about the code-base itself. I remember once mentioned that they used the same approach while developing Alchemix Finance on . Scupy Trooples Bankless In addition to that, built-in fuzzing, cheat codes, Cast, and Anvil make it a solid suite for testing smart contracts. There will be more detailed articles on those components coming soon. [Easy to integrate static analyzer] Let’s dive in and build an NFT project now. Installation: If you are on Mac or Linux, all you need to do is run two commands: curl -L https://foundry.paradigm.xyz | bash foundryup Make sure to close the terminal before running . foundryup And Voila! You are all done. For Windows, you need to have Rust installed and then : cargo install --git https://github.com/foundry-rs/foundry --locked Project Setup: For this article, we will be creating a simple NFT project called Figbots. Start by creating a directory called “Figbots.” And  run once you are inside the directory. This command will create a foundry project for you with initialized. forge init git Let’s take a quick look at the folder structure. You have three primary folders, namely src, lib, and test. Very much self-explanatory here, you write your contracts in , tests in , and contains all the libraries you installed, e.g., OpenZeppelin. In addition to that, you get which contains all the configurations just like and if you have used those frameworks. Another sweet thing is .github, where you can write your Github Actions. I find it really helpful for tests when working in a team. src test lib foundry.toml hardhat.config.js brownie-config.yaml Let’s start building! We will create a simple NFT called Figbot with a limited supply, cost (for minting), and withdrawal. With this approach, we can cover edges for different tests. First of all, rename and to and respectively. Now, we can not write smart contracts without Openzeppelin, can we? Contract.sol test/Contract.t.sol Figbot.sol Figbot.t.sol Installing libraries with Foundry is slightly different than Hardhat and Brownie. We don’t have npm or pip packages. We install libraries directly from the Source (GitHub repo) in Foundry. forge install Openzeppelin/openzeppelin-contracts Now we can import the ERC721URIStorage.sol extension to create our NFT. To check that everything is alright, we can run the command , and it will compile our project. The compiler will yell at you if there is something wrong. Otherwise, you will get a successful compile. forge build Managing dependencies Just like any other package manager, Forge allows you to use , and to manage your dependencies. forge install <lib>, forge remove <lib> forge update <lib> Let’s Complete The NFT Contract: We will be using three contracts from the Openzeppelin. Counters, ERC721URIStorage, and Ownable. Time to upload our to IPFS using . We use the Ownable contract to set deploying address and have access to modifier to allow only the owner to withdraw funds. to help us with token id(s) and to keep the NFT contract simple. asset Pinata owner onlyOwner Counters ERC721URIStorage Setting state variable: to 100 MAX_SUPPLY to 0.69 ether COST to CID, we receive from Pinata TOKEN_URI Using Counter for token id: using Counters for Counters.Counter; Counters.Counter private tokenIds; ERC721 constructor: constructor() ERC721(“Figbot”, “FBT”) {} Mint function: Check if is greater than msg.value COST Check if is greater or equal to tokenIds.current() MAX_SUPPLY Perform and _safeMint _setTokenURI Withdraw function: function withdrawFunds() external onlyOwner {         uint256 balance = address(this).balance;         require(balance > 0, "No ether left to withdraw");         (bool success, ) = (msg.sender).call{value: balance}("");         require(success, "Withdrawal Failed");         emit Withdraw(msg.sender, balance);     } TotalSupply function: function totalSupply() public view returns (uint256) {                                         return _tokenIds.current();        } Testing The Contract: As we all know, testing our smart contracts is really important. In this section, we will be writing some tests to get a solid understanding of and get used to writing tests in native solidity. We will be three (I love them!) to manage account states to fit our test scenario. forge test Foundry cheat codes We will be testing for the following scenarios: Max Supply Successful mint Failed mint due to insufficient balance Withdraw (by owner) Cheatcodes As we can have complex logic in our smart contracts. And they are expected to behave differently depending on the state, the account used to invoke, time, etc. To deal with such scenarios, we can use cheatcodes to manage the state of the blockchain. We can use these cheatcodes using instance, which is a part of  Foundry’s library. vm Test We will be using three cheatcodes in our tests : : Sets for all subsequent calls until is called. startPrank msg.sender stopPrank : stopPrank Stops an active prank started by , resetting and to the values before was called. startPrank msg.sender tx.origin startPrank : Sets the balance of an address provided address to the given balance. deal Setup Foundry comes with a built-in testing library. We start by importing this test library, our contract (the one we want to test), defining the test, setting variables, and function. setUp pragma solidity ^0.8.13;

import"forge-std/Test.sol";
import "../src/Figbot.sol";

contract FigbotTest is Test {

  Figbot figbot;
  address owner = address(0x1223);
  address alice = address(0x1889);
  address bob = address(0x1778);
  
  function setUp() public {
      vm.startPrank(owner);
      figbot = new Figbot();
      vm.stopPrank(); 
  }
} For state variables, we create a variable of type . This is also the place where I like to define user accounts. In Foundry, you can describe an address by using the syntax . you can use any four alphanumeric characters for this. I have created the accounts named owner, Alice, and bob, respectively. figbot Figbot address(0x1243) Now our function. This is a requirement for writing tests in Foundry. This is where we do all the deployments and things of that nature. I used the cheatcode to switch the user to the “owner.” By default, Foundry uses a specific address to deploy test contracts. But that makes it harder to test functions with special privileges like . Hence, we switch to the “owner” account for this deployment. setUp startPrank withdrawFunds Test MaxSupply: Starting with a simple assertion test to learn Foundry convention. By convention, all the test functions must have the prefix . And we use to test if two values are equal. test assertEq We call our function and test if the result value is 100, as we described in our contract. And we use to run our tests. MaxSupply forge test And Voila!!! we have a passed test. Test Mint: Now that we have written a simple test, let’s write one with cheatcodes. The primary function of our contract. Switch user account to Alice. Set Alice’s balance to 1 ether Call the mint function Check if Alice is 1 balanceOf TestFail Mint: We have another testing function used for tests that we expect to fail. The prefix used for such a test is . We will test if the function reverts if the caller has insufficient funds. testFail mint Switch user account to Bob Set Bob’s balance to 0.5 ether (our NFT is 0.69 ether) Call the mint function (it will be reverted due to not having enough funds) Check if Bob is 1 balanceOf Because mint didn’t go through, the balance of Bob is not going to be 1. Hence, it will fail, which is exactly what we are used for. So when you run , it will pass. testFail forge test Test Withdraw: Here we will test a function that only the “owner” can successfully perform. For this test, we will : Switch user to Bob Give Bob’s account the balance of 1 ether Mint a Figbot from Bob’s account ( this will give the contract a balance of 0.69 ether ) Switch the user to the owner account Perform function ( if successful, it should make the owner’s balance 0.69 ether) withdrawFunds To verify, we assert if the owner’s balance is 0.69 ether Deployment: Now that we have tested our contract, it is time to deploy it. We need private keys to a wallet (with some Rinkeby test ETH) and an RPC URL. For our RPC URL, we will use . Figment DataHu Figment DataHub provides us with infrastructure to develop on Web 3. It supports multiple chains like Ethereum, Celo, Solana, Terra, etc. Setting up Figment DataHub: Create an account on . Figment DataHub Click on “Create New App.” Fill in the app name. Choose “Staging” for the environment. Select “Ethereum” from the provided options. You can get your RPC URL for Rinkeby from under the “Protocols” tab. Open your terminal to enter both of these things as environment variables. export FIG_RINKEBY_URL=<Your RPC endpoint>
export PVT_KEY=<Your wallets private key> Once we have the environment variables, we are all set to deploy forge create Figbot --rpc-url=$FIG_RINKEBY_URL --private-key=$PVT_KEY Verification: We are almost done here. So far, we have written, tested, and deployed a smart contract with Foundry and Figment DataHub. But we are not entirely done just yet. We are now going to verify our contract. We will need to set up our API key for that. Etherscan export ETHERSCAN_API=<Your Etherscan API Key> And now we can verify our smart contract. forge verify-contract --chain-id <Chain-Id> --num-of-optimizations 200  --compiler-version <Compiler Version> src/<Contract File>:<Contract>  $ETHERSCAN_API Congratulations! Now you can write, test, and deploy smart contracts using Foundry. I hope you enjoyed and learned from this article. I indeed enjoyed writing this. Feel free to let me know your thoughts about it.

How to Build an NFT Project with Foundry & Figment DataHub

Cómo construir un proyecto NFT con Foundry & Figment DataHub

Comment créer un projet NFT avec Foundry & Figment DataHub

फाउंड्री और फिगमेंट डेटाहब के साथ एनएफटी प्रोजेक्ट कैसे बनाएं?

Foundry & Figment DataHub を使用して NFT プロジェクトを構築する方法

Como construir um projeto NFT com Foundry & Figment DataHub

Cách xây dựng một dự án NFT với Foundry & Figment DataHub

如何使用 Foundry 和 Figment DataHub 构建 NFT 项目

Building a Classic Web3 NFT Minting Dapp with React and Solidity: Part 1

Building a Full Stack NFT Minting DApp Using Hardhat, Ethers.js, Next.js, and TailwindCSS

NFTs are the new/old superstars of blockchain. An NFT can represent a picture (or any piece of art), an object in the virtual or the real world, or any other non-fungible thing. If you wonder how NFTs work you can read a short introduction in . my older NFT article In this article, I’ll show you, how you can create your very own NFT contract, and mint your own NFTs on any Ethereum compatible chain mainnet such as Polygon, xDai, etc. is a smart contract framework with many smart contract templates and libraries. Something like a swiss army knife for smart contract developers. It also has an that allows you to create simple smart contracts within a minute. Let’s see, how can we create an NFT contract with it. OpenZeppelin online wizard is the NFT standard, so choose it on the tab bar, then check , , and .  You will see the autogenerated code on the right side. On the block, you can set your token name and symbol. From these few steps, you’ve configured a fully functional NFT contract. Deploying it to the blockchain is just as easy. ERC721 Mintable Autoincrement Ids URI storage Settings Click on the Open in Remix button that will open a new page for you with Remix. The first step is compiling the contract that you can do with the 2nd menu item (Solidity compiler). Compile contract by using the Compile contract button, and choose the 3rd menu item (Deploy and run transactions) for deploying the contract. On this page, choose the Injected web3 environment to connect Metamask to Remix, choose the token contract, and push the Deploy button. If everything goes well, Metamask will pop up a Confirm dialog. Confirm the transaction, wait for a little for the miners, and… done. Congratulations, you have your own deployed NFT contract! You will see your deployed contract on the bottom of the left side. If you move your mouse pointer over the token name, you can copy its contract address. Write it down somewhere, because it will be important later. Let’s mint our first NFT with our brand new token contract! When you mint an NFT, you have to give a URI that points to the NFT metadata. This metadata describes what the NFT represents. Technically this metadata is a simple JSON file. The basic format of the JSON file is defined in ERC-721 but it is freely extendable. The basic fields are name, description, and image, so the JSON file looks like this: {
  "name": "Sample token",
  "description": "This is my first token, minted with my own token contract",
  "image": “...image url..”
} The standard doesn’t define where the metadata should be placed, but immutable storage, like is ideal storage for the NFT metadata. is a simple service for uploading your NFT data and publishing it to IPFS. It has a free plan that gives 1Gb storage which is more than enough for us, so choose your favorite image and upload it to Pinata. IPFS Pinata After the upload, you will see the generated CID of the image. This is the unique identifier of it on the IPFS. You can check your file through the public IPFS gateway on the URL. https://ipfs.io/ipfs/{cid} Now we have the image CID, so we can easily create the metadata JSON. My JSON looks like this: {
  "name": "Sample token",
  "description": "This is my first token, minted with my own token contract",
  "image": "ipfs://QmXgZ8KcwU18MU3Wkzt7ki2P2XxSDQaNtyb8kjbk2enGQr"
} We can go back with the metadata JSON CID to Remix and mint our first NFT token. To do this, open the token contract on the bottom of the left side and open safeMint. The function has two parameters. The Ethereum address of the NFT owner (must be different than the contract creator) and the metadata URI. The URI will be ipfs://{CID of the metadataJSON}. safeMint Push the transact button, confirm the transaction in MetaMask, and voila you’ve minted a new NFT token that you can check on . OpenSea is an NFT marketplace where you can sell or buy NFTs on many Ethereum compatible chains. OpenSea The URL of your token on OpenSea is {contract address}/{NFT id}. OpenSea has a test interface that you can use for showing NFTs from a testnet. I created my NFT contract on Rinkeby so I will use this alternative URL where the host part is . https://opensea.io/assets/ testnets.opensea.io My current URL is because my token contract address is 0xdfe0e842371b3286820c188a6e855fd7f1da7e09 and the first NFT’s index is 0. https://testnets.opensea.io/assets/0xdfe0e842371b3286820c188a6e855fd7f1da7e09/0 You can see the name from the meta on the right side, and the image with the description on the left side. This NFT is fully functional. I could sell it or do anything that I can do with any other NFT. As you can see, creating NFT contracts and minting NFTs are super simple with great tools like OpenZeppelin, Remix, or MetaMask. Even if you don’t have any programming experience. Have fun and make NFTs…

Create An EVM-Based NFT Contract without Programming Skills: A How-To Guide

Both iOS and Android provide built-in device-level checks which can help prevent mobile application abuse. On iOS, provides a way to associate a few pieces of information per app with each device, On Android, device attestation attempts to ensure that a device is running in a safe environment. These are useful capabilities, but they are only a small part of an in-depth mobile app and API protection scheme. DeviceCheck SafetyNet Trust me! For almost all useful apps today, interaction with remote services through APIs is the major mode of operation. While security concerns often seem to focus on user authentication, all possible attack surfaces must be considered to ensure a secure API transaction. From the perspective of the API service, all API calls must be protected by a secure channel between app and service. Although encrypts the channel, a clever attacker may compromise certificate authority on the device or network, so , which can be difficult to implement and maintain, should be used to protect against man-in-the-middle attacks. TLS certificate pinning Secondly, the API service must have confidence that the app running on the device is authentic. All fake or tampered apps must be rejected. The most common form of app authentication when making an API call is the venerable (and vulnerable) static API key. No matter how well hidden, if hacking the API service is valuable enough, the API key will be stolen, either by reverse engineering in the app or by observing it in an unpinned channel. Reliable tamper-detection techniques are a must, and decisions about the authenticity of an app should always be made outside the app itself in case the checks themselves are tampered with or bypassed. can protect against both fake and tampered apps. The app’s package, installed code, and the run time environment are all potential attack surfaces for tampering. Remote mobile app attestation techniques If you have a secure channel and an authentic app, it’s finally time to worry about properly authenticating and authorizing the user using protocols like and combined with biometric and/or . But don’t forget, user authentication is only as strong as the other factors. Standard OAuth2, for example, uses a secret for app authentication, and that’s not enough to prevent a fake app from stealing user credential info. OAuth2 OIDC multi-factor authentication By a long shot, app authentication is the weakest link in the mobile API security chain today. So how well do on iOS and on Android help with app authentication? DeviceCheck SafetyNet iOS DeviceCheck DeviceCheck provides developers a reliable way to identify a device and can store two bits of information about the device per app. The flags are maintained even if the app is deleted and reinstalled, a user logs in with different credentials or a system reset is performed. Typical flags might include ‘Has this device ever been compromised?’ or ‘Has this app’s free promotion period been used for this device?’. (Source: ) Uniquely identify iOS device using DeviceCheck The DeviceCheck API generates an ephemeral token which uniquely identifies the device to Apple. Your API service combines this token with an authentication key from Apple and requests or updates the flags identified by the per-device bits and maintains a timestamp indicating when they were last modified. The DeviceCheck implementation assures users of their privacy even while uniquely identifying the device. Developers receive only an ephemeral token, rather than a device serial number or any other identifying information. Similarly Apple stores the flags and timestamps but has no idea of how the flags are interpreted. From an app authentication perspective, the flags could be used to identify compromised devices or apps, but it is still up to the developer to determine the app’s authenticity. Since app and device conditions change frequently, the ability to store the last authenticity check is of only marginal value. provides more information on how DeviceCheck compares with a state of the art app authentication system. DeviceCheck and Approov Android SafetyNet On Android, SafetyNet is installed as part of Google Play Services installed on Google-approved Android devices. It consists of four APIs: SafetyNet Attestation API — compares the device environment to known device profiles to identify if the device is rooted or potentially compromised. SafetyNet Safe Browsing API: Checks if a URL matches a URL known by Google to be malicious. SafetyNet reCAPTCHA API: Analyzes user interactions with an app to provide a confidence estimate on whether the user is actually a bot. SafetyNet Verify Apps API: Checks if any known malicious apps are installed on the device. (Source: ) Inside Android SafetyNet Attestation When using the device attestation API, an app makes a call to the device attestor which sends run time measurements to Google Play Services. Google evaluates the information and provides a cryptographically secure assessment back to the app. The app then forwards the assessment on to the API service for validation. The assessment decision is made outside the app, which is good practice, and the assessment decision can be used by the app to, for example, shut down a mobile-banking app if it is running on a rooted or non-standard phone setup. Apps must be constantly evaluating not just device health but the health of the application itself. SafetyNet provides limited but effective run-time checks; however, most apps will need additional, more app-specific checks. SafetyNet provides some protection against Fake or tampered apps by reporting the application signature, but full app attestation provides far more protection against zero-day and more dynamic exploits. Note also that access to Google Play Services is required to use SafetyNet. provides more information on how SafetyNet compares with a state of the art app authentication system. SafetyNet and Approov Going Further DeviceCheck and SafetyNet are potentially useful parts of a mobile API defense in depth security approach. DeviceCheck enables you to mark your app or device as untrusted if you can detect that by some other means. SafetyNet provides more structured checks of the device’s run time environment. Both services can augment but are no replacement for solid app attestation techniques. For a more in-depth look at mobile API focused security, take a look at the from OWASP AppSec California 2019. Preventing Mobile App and API Abuse presentation Thanks for reading! For more information on mobile API security, check out . www.approov.io

What Role do DeviceCheck and SafetyNet play in App Authentication?

This paper is available on arxiv under CC 4.0 license. Authors: (1) Dylan Warman, School of Computing, Charles Sturt University; (2) Muhammad Ashad Kabir, School of Computing, Mathematics,. Table of Links Abstract & Introduction Related Works Materials and Methods Results and Discussion Conclusion & References II. RELATED WORK The current landscape of tools for detecting fake news reveals several limitations and gaps in addressing the critical need for accessible and explainable solutions. CoVerifi [12] is a functional application that provides accurate classifications and human generation scores for COVID-19-related news articles, but it lacks genuine explainability techniques, leaving users without a comprehensive understanding of the reasoning behind the classification. However, a more fundamental issue highlighted by dEFEND [13] is the scarcity of tools accessible to end-users for detecting fake news. A notable example of such limitations is FakerFact [14], a Chrome extension that analyzes and verifies fake news by URL. Although it offers classification percentages in various areas, it falls short of providing direct explainability. Similarly, SEMiNExt [15] analyses user search terms for potential fake news content without explaining or classifying actual news articles. While there are tools [11] like xFake [16] that demonstrate the potential for sentiment and linguistic analysis with explainable outputs, they often have limitations, like being restricted to specific websites, as seen in xFake’s compatibility with PolitiFact [17] only. Despite these limitations, tools like Bunyip [18] provide promising visual explainability outputs and classifications for human-generated text, showing that similar applications can be developed. However, these tools do not directly address traditional fake news detection, although they serve as proof of concept for the feasibility of creating user-friendly and explainable applications. In summary, the existing tools fall short of providing comprehensive and user-friendly solutions for detecting fake news, particularly identifying COVID-19-related fake news with explainability. There is a significant gap between the state-of-theart studies on machine learning and explainability techniques for fake news, and the ideal end-user tools that offer both accurate classifications and clear interpretable explanations. While the above-discussed tools demonstrate progress, they underscore the necessity for a holistic approach that provides a user-friendly experience coupled with meaningful explainability to empower users in identifying and understanding fake news.

COVIDFakeExplainer: An Explainable Machine Learning based Web Application: Related Works

This paper is available on arxiv under CC 4.0 license. Authors: (1) Dylan Warman, School of Computing, Charles Sturt University; (2) Muhammad Ashad Kabir, School of Computing, Mathematics,. Table of Links Abstract & Introduction Related Works Materials and Methods Results and Discussion Conclusion & References V. CONCLUSION This paper presents a comprehensive pipeline encompassing the entire process, from training machine learning models to prototype implementation, for the detection of fake news with explainability. Our study demonstrates the potential of combining machine learning and explainability techniques to create a web application tailored for detecting COVID-19- related fake news. Through an extensive empirical analysis, we evaluated the performance of three prominent machine learning algorithms for text classification across seven distinct configurations, employing two distinct datasets. The results indicate that BERT emerges as the optimal choice for COVID19 fake news classification. Moreover, we critically examined the two leading explainability visualization techniques, offering insights into their respective advantages and limitations. Finally, we developed a prototype web application in the form of a Chrome extension. This approach is highly adaptable and can be extended beyond COVID-19 fake news detection, for instance, to classify text or misinformation in a variety of domains. The only requirement for this adaptation is the replacement of the model that serves as the foundation for the application. In the future, we plan to further improve the application’s robustness by incorporating a larger and more comprehensive dataset. Additionally, we intend to conduct thorough evaluations to assess the usability and performance of the application. REFERENCES [1] X. Zhou and R. Zafarani, “A survey of fake news: Fundamental theories, detection methods, and opportunities,” ACM Computing Surveys (CSUR), vol. 53, no. 5, pp. 1–40, 2020. [2] A. Sanaullah, A. Das, A. Das, M. A. Kabir, and K. Shu, “Applications of machine learning for covid-19 misinformation: a systematic review,” Social Network Analysis and Mining, vol. 12, no. 1, p. 94, 2022. [3] D. M. Lazer, M. A. Baum, Y. Benkler, A. J. Berinsky, K. M. Greenhill, F. Menczer, M. J. Metzger, B. Nyhan, G. Pennycook, D. Rothschild, and et al., “The science of fake news,” Science, vol. 359, no. 6380, p. 1094–1096, 2018. [4] A. Watson, “Problems with finding coronavirus news worldwide 2020,” https://www.statista.com/statistics/1104506/coronavirusnews-opinions-worldwide/, 2020, accessed: 30 August, 2023. [5] ——, “Sharing of made-up news on social networks in the u.s. 2020,” https://www.statista.com/statistics/657111/fake-news-sharing-online/, 2023, accessed: 30 August, 2023. [6] S. Vosoughi, D. Roy, and S. Aral, “The spread of true and false news online,” Science, vol. 359, no. 6380, p. 1146–1151, 2018. [7] M. A. Britt, J.-F. Rouet, D. Blaum, and K. Millis, “A reasoned approach to dealing with fake news,” Policy Insights from the Behavioral and Brain Sciences, vol. 6, no. 1, p. 94–101, 2019. [8] G. Pennycook and D. G. Rand, “The psychology of fake news,” Trends in Cognitive Sciences, vol. 25, no. 5, p. 388–402, 2021. [9] T. L. I. Diseases, “The covid-19 infodemic,” The Lancet Infectious Diseases, vol. 20, no. 8, p. 875, 2020. [10] W. Samek, T. Wiegand, and K.-R. Muller, “Explainable artificial in- ¨ telligence: Understanding, visualizing and interpreting deep learning models,” CoRR, vol. abs/1708.08296, 2017. [11] J. Ayoub, X. J. Yang, and F. Zhou, “Combat COVID-19 infodemic using explainable natural language processing models,” Information Processing & Management, p. 102569, mar 2021. [12] N. L. Kolluri and D. Murthy, “CoVerifi: A COVID-19 news verification system,” Online Social Networks and Media, vol. 22, 2021. [13] K. Shu, S. Wang, L. Cui, D. Lee, and H. Liu, “dEFEND: Explainable Fake News Detection,” dl.acm.org, pp. 395–405, jul 2019. [14] Y. Ma, D. Towey, T. Yueh Chen, and Z. Quan Zhou, “Metamorphic testing of fake news detection software,” 2021 IEEE 45th Annual Computers, Software, and Applications Conference (COMPSAC), 2021. [15] A. B. Shams, E. Hoque Apu, A. Rahman, M. M. Sarker Raihan, N. Siddika, R. B. Preo, M. R. Hussein, S. Mostari, and R. Kabir, “Web search engine misinformation notifier extension (seminext): A machine learning based approach during covid-19 pandemic,” Healthcare, vol. 9, no. 2, p. 156, 2021. [16] F. Yang, S. K. Pentyala, S. Mohseni, M. Du, H. Yuan, R. Linder, E. D. Ragan, S. Ji, and X. B. Hu, “Xfake: Explainable fake news detector with visualizations,” The World Wide Web Conference on - WWW ’19, 2019. [17] Poynter Institute, “Politifact,” https://www.politifact.com/, accessed: 30 August, 2023. [18] R. Sawant, “Bunyip,” https://awesomeopensource.com/project/CT83/ Bunyip, accessed: 30 August, 2023. [19] L. Cui and D. Lee, “CoAID: COVID-19 healthcare misinformation dataset,” 2020. [20] M. Cheng, S. Wang, X. Yan, T. Yang, W. Wang, Z. Huang, X. Xiao, S. Nazarian, and P. Bogdan, “A COVID-19 rumor dataset,” Frontiers in Psychology, vol. 12, 2021. [21] Z. Li, F. Liu, W. Yang, S. Peng, and J. Zhou, “A survey of convolutional neural networks: Analysis, applications, and prospects,” IEEE Trans. Neural Netw., vol. 33, no. 12, pp. 6999–7019, 2022. [22] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova, “BERT: Pretraining of deep bidirectional transformers for language understanding,” in Proceedings of NAACL-HLT. Minneapolis, Minnesota: Association for Computational Linguistics, 2019, p. 4171–4186. [23] C. Colon-Ruiz and I. Segura-Bedmar, “Comparing deep learning archi- ´ tectures for sentiment analysis on drug reviews,” Journal of Biomedical Informatics, vol. 110, 2020. [24] J. Y. Khan, M. T. Khondaker, S. Afroz, G. Uddin, and A. Iqbal, “A benchmark study of machine learning models for online fake news detection,” Machine Learning with Applications, vol. 4, 2021. [25] A. Ezen-Can, “A comparison of LSTM and BERT for small corpus,” ArXiv, vol. abs/2009.05451, 2020. [26] S. M. Lundberg and S.-I. Lee, “A unified approach to interpreting model predictions,” in Proceedings of the 31st International Conference on Neural Information Processing Systems, 2017, p. 4768–4777. [27] M. T. Ribeiro, S. Singh, and C. Guestrin, ““why should i trust you?”: Explaining the predictions of any classifier,” in Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. ACM, 2016, p. 1135–1144.

COVIDFakeExplainer: An Explainable Machine Learning based Web Application: Conclusion & References

Let's learn about via these 30 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Smart Home /Learn Repo 1. 5 Most Pointless Smart Life Devices to Stay Away From A selected review of the most frustratingly pointless smart life devices available today. 2. How Smart are our Homes Getting? Smart spaces will become an essential part of our lives, he says. Smart homes are changing our lives in the same way as wearable devices. 3. All You Need To Know About UX Design In The Ambient Computing Era Ambient/Ubiquitous computing is a concept that circumscribes many terms together. It can be considered as a magnificent amalgam of software, hardware products and user experience with a major component of human-machine interaction and learning, all of these things becoming the aim of using a computer or any internet-enabled device, without necessarily deliberately using it. 4. Best Ways to Conserve Electricity and Save Money with Household Tech You just can't put enough information into one article to elucidate the processes of going green with solar electricity, so we're getting to break it into three steps. This first article is "Step One, Determining your Current Use." In it, we'll check out the way to determine what proportion of energy you employ at the present and the way to lower your consumption. 5. What the New CHIP Standard Means for Smart Home Startups When most people hear the word “chip” in the context of a smart home, they immediately imagine the microchips at the heart of their smart devices. But whereas chips power the brains of an individual smart device, CHIP will power the brains of an entire smart home. CHIP will offer huge conveniences to consumers, but its openness may make it harder for hardware startups to build ecosystems and defend against inexpensive knock-offs. 6. How to Build An Alexa Home Automation System How to make an IoT-based Smart Home with Arduino IoT Cloud & Alexa using NodeMCU ESP8266 to control 4 home appliances with voice commands. 7. How to Connect Your Soundbar to External Components It only takes a few minutes to connect your soundbar to your TV and get it running. But what if you want to set it up for another device, such as a gaming console or a Blu-ray player? Here, we go through the details such as the cables you need and settings you may have to change in your TV’s menu. 8. Big Tech Is Acquiring Access to Your Health & Home SMART HOMES: THE FINAL FRONTIER 9. Detecting Humans in Smart Homes with Computer Vision Learn more about OpenCV, how you can use it to identify and track people in real-time, and what challenges you can meet. 10. The Internet of Things will Transform these 7 Industries The Internet of Things (IoT) is a network of physical objects, including vehicles, medical devices and home appliances, that use sensors and APIs to connect to one another and exchange data over the internet. 11. No Safety Nets in the Real World The Dark Side of the Smart Revolution 12. What Are The Cybersecurity Risks Associated With Personal Devices? Let's look at some of the most significant risks posed by your personal digital devices, and what we can do to boost your security. 13. How IoT And Edge Computing Influence Various Industries From healthcare to lifestyle, everything is being influenced by emerging technologies like IoT and edge computing. Moreover, as data remains the foundation of today’s economy, businesses can use these emerging technologies to offer a more personalized experience to their customers. 14. Using IoT to Solve Housing Problems and Improve Safety IoT can help manage air quality and emissions at industrial sites, improve control over electricity, water, and heat meters, and more. 15. Self-Isolation and Electricity: 3 Problems That May Arise Quarantine has drastically affected our routine. Companies have switched to remote work, employees have no choice but to work from home and get used to a new rhythm of life. Now as never before we all rely on uninterrupted Internet access. Sudden power outages reduce our productivity and affect the work schedule. 16. Smart Home Technology Sales Projected At $317 Revenue By 2026 Housewares have become more intelligent than ever, and the sales of smart home technologies are on the rise. 17. Technology To Make You Feel Safer Online Cybercrimes continue to be rampant and most people continue to wonder about their safety and that of their information. 18. How Technology Changing Our Homes Do you remember the pre-technology homes? Hard to recollect, right? Technology has changed our lives most remarkably and it is still transforming at a rapid space. 19. Smart homes are getting mainstream: 85% of Americans bought a smart device in 2020 According to the Safewise study, 85% of Americans bought a smart home device in 2020, and three-quarters of them were 44 or younger. 20. 12 Ways To Enforce IoT Security In Your Smart House IoT security in home automation is critical to avert data theft & infiltration of devices. Here are some ways that can help you out. 21. Smart Home Technologies that Will Raise the Value of your Home Smart homes are rapidly becoming popular across different demographics, and all for good reasons. For starters, smart security systems can detect break-in attempts and alert the authorities even in your absence. Some smart detectors can detect smoke, moisture level, carbon monoxide among other factors that can harm the home. Smart devices save money and allow convenience and efficiency in a huge way. In addition, smart home devices are easy to install. You only need the right tools and instructions to get started. 22. How to Take an Advantage Of Home Automation A couple of weeks ago I created an automation to change the light in my living room for when I played video games. 23. Major Reasons Why You Have Wi-Fi Dead Zones In the event that you have certain rooms or regions in your home where the Wi-Fi signal is moderate or nearly non-existent, you may have a Wi-Fi no man’s land. Does it take everlastingly to stack a page on the PC in your room? Is it practically difficult to watch Netflix in the cellar? No man’s lands and moderate zones can cause your gushing sticks, PCs, and savvy home gadgets to run ineffectively, conflictingly, or in some cases, not under any condition. 24. The Rapid Fire Adoption of Smart Home Tech A look at the smart homes and smart devices of the future, lead by Millennials and Gen Z generations. 25. DIY Tutorial: How to Create Motorized Shades for Your Smart Home Inexpensive motorized shades are a holy grail for DIY smart home enthusiasts. Many have tried and failed to produce a product that is comparable to the market. 26. Ajax Interacting With Security Systems Champion: Type 5 Certification Scheme Type 5 Certification Scheme is the most ruthless quality control in the security industry. Learn how Ajax smart wireless alarm goes through it 27. Connecting to Schlage's New WiFi Locks Is Not Easy I like Schlage’s smartlocks, and have used them for years. Built by a company with a long history of making reasonably secure, reliable locks, I’ve used several of their Z-Wave locks over the years, but Z-Wave is…Z-Wave. Proprietary until recently, a PIA to troubleshoot, and while the technology held a lot of promise on paper, in reality it’s been the cause for many a swear word to erupt from my mouth (I realize this is partially due to the controllers I’ve used over the years). 28. Top 10 Innovations in IoT, HealthTech, Fraud Prevention and More While 2020 might not have gotten off to the best of starts, hope lies in the future as we prepare for a new and exciting list of technology and software development yet to come. Tech companies across the world have been working tirelessly to provide consumers with an exciting array of innovations that will shape the world. 29. Home Gadgets that Drive Adults Crazy The HN team discussed their favorite smart home gadgets and what developments they wish to see available on the market. 30. Energy Savings Strategies for Smart Homes Let’s explore some energy-saving strategies for smart homes that you can deploy today and make your homes green and energy-efficient. Thank you for checking out the 30 most read stories about Smart Home on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

30 Stories To Learn About Smart Home

ZKP Meets ML in Verifiability: Existing Scheme & Experimental Analysis

Let's learn about via these 83 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Entertainment /Learn Repo 1. The 59 Questions From the Will Ferrell Joaquin Phoenix Interview On March 28 2018, Interview Magazine published Joaquin Phoenix Interview by Will Ferrell, and it became known as the greatest interview ever published. 2. How Many Oscars Does Will Smith Have? Answering All of Your Oscar-Related Questions How many Oscars does Leonardo DiCaprio have? How many Oscars does Anthony Hopkins have? 1 and 2, respectively. Find out how many Will Smith has. 3. Every Doctor Strange Appearance in Order Doctor Strange 2. Thor: Ragnarok 3. Avengers: Infinity War & Endgame 4. Spider-Man: No Way Home 5. Doctor Strange in the Multiverse of Madness 4. The Tom Holland Spider-Man Movies in Order of Release Date Here are the Tom Holland Spider-Man Movies in order: 1. Homecoming 2. Far From Home 3. No Way Home 5. All of the Ant Man Movies in Order Ant-Man. 2. Ant-Man and the Wasp. 3. Ant-Man and the Wasp: Quantumania 6. How AI Is Transforming the Entertainment Industry To appreciate how digital transformation is changing society, it helps to examine how ai and machine learning will impact particular industries 7. Every Thanos Appearance in Order Here's every Thanos appearance: 1. The Avengers 2. Guardians of the Galaxy 3. Avengers: Age of Ultron 4. Avengers Infinity War and Endgame 5. What If? 8. The Dark Knight Movies in Order If you never got to experience them, have no fear. Here’s a list to explain how to watch them. Without further ado, here are The Dark Knight Movies in Order. 9. All Marvel Movies Coming Out in 2023 Here are all of the Marvel 2023 movies: Ant-Man 3, Guardians of the Galaxy 3, Spider-Verse 2, The Marvels, and Kraven the Hunter. 10. The Live-Action Mortal Kombat Movies in Order Mortal Kombat Movies in Order: Mortal Kombat (1995), Mortal Kombat: Annihilation, Mortal Kombat (2021) 11. Ten Important Factors to Consider When Choosing a Streaming Service Things to consider when choosing a streaming service 12. The New Godzilla Movies in Order Godzilla and King Kong make their triumphant return to the big screen as part of the Monsterverse franchise. 13. The 5 Best Mystery Games on Xbox Some of the best mystery games on Xbox include Danganronpa and Oxenfree. Find out why, and learn more about other great mystery games. 14. How to Compete with Netflix: Beyond the Streaming Experience Streaming is all about creating a great viewing experience 15. If Glitch Techs is Any Indication, the Nickelodeon and Netflix Partnership is a Winning Deal (Photo used with permission from Eric Robles and Dan Milano) 16. How Staking Has Taken Over the Crypto Industry NFTs are taking the music industry to levels beyond what anyone a decade ago could not fathom. 17. Startup Interview with Erik Norgaard, HOLLYFY Founder / CEO Built for the creator economy. Empowering small businesses. Expanding spheres of influence. Erik Norgaard shares the origin story of Hollyfy. 18. The MCU Phase 2 Movies in Order It continued storylines from the first phase, but it also introduced new characters and heroes. In total, phase 2 was composed of 6 films. 19. Cyberpunk is Now: Dystopia or Utopia? This article is not important. It does not contain relevant information or any interesting study on any subject. It is just a small reminder to remind you that today is an excellent time to be alive. 20. Everything You Need to Know About Master of the Star Spring After watching the first season of Master of the Star, I’m already eager to see the second season of the series. 21. The Last of Us HBO Series; The Nth of Many As Naughty Dog's Award-winning game title, The Last of Us, makes its way to TV screens. I take a look at the relationships between gaming and TV. 22. Web3's Role in the New Golden Age of Entertainment: Insights from Press Start Capital's Steven Chien "Behind the Startup" is excited to have Steven Chien, founder of Press Start Capital, a venture capital firm that focuses on the intersection of entertainment. 23. Why Streaming Has Not Conquered the World Read this post to understand how the trials of Netflix and Spotify have underlined a reality about the fragility of the streaming industry. 24. The British Are to Blame for the Term "Soccer" The British coined the term soccer, NOT Americans 25. Decentralization of the Entertainment Industry To Solve Its Woes Around Publishing and Profits In the early days of blockchain technology, the general belief was that blockchain was all about cryptocurrencies, but things are dramatically changing. We now know that blockchain transcends all spheres of life. 26. The Avengers Movies in Order The Avengers movies in order: Marvel's The Avengers, Age of Ultron, Infinity War, and Endgame. 27. The Best Places to Read Digital Comics There are several places to read digital comics. Some of these places include Marvel Unlimited and Prime Reading. 28. Three Questions for Netflix’s New Co-CEOs Read this post for a deep dive into Netflix's three growth imperatives for 2023.. 29. The Super Mario Movie: Release Date, Cast, and Everything You Need to Know Who’s voicing Mario? Who’s the studio behind the movie? When is it coming out? Don’t worry because here’s everything you need to know about the Mario movie. 30. Shaping the Future of Entertainment: Web3.0 and Play-to-Earn Games The combination of these two forces will significantly impact the future of entertainment. 31. Injustice Movie Announced The Injustice video game story has been praised by fans for years, and it looks like it's being adapted into a movie. Here's what we know so far. 32. Corona Porn: The Arousal of a Pandemic The media calamity of “The Corona” is disturbing and dismal, but even still, many are buzzed. It’s so titillating that we just can’t help but… participate ourselves. 33. NFTs and The Sports Industry: The Perfect Pair In this article, let’s find out what values NFTs bring to the sports world and how they contribute to the development of the sports industry. 34. The MCU Phase 1 Movies in Order MCU Phase 1 Movies in Order: Iron Man, The Incredible Hulk, Iron Man, Thor, Captain America: The First Avenger,  and Marvel’s The Avengers. 35. The Captain America Movies in Chronological Order There are a ton of Captain America movies. Some might find it difficult to know the chronological order for watching them. So, here's a convenient guide. 36. 5 Must-see Movies Coming Out in 2023 2023 seems like it will be a great year for films. Here are 5 must-see movies coming out in 2023, including Mission Impossible and Oppenheimer. 37. All of the Marvel Phase 5 TV Shows Announced Marvel's Phase 5 is packed to the brim with exciting projects. Everything from Secret Invasion to Loki season 2. 38. The Wolverine Movies in Order If you only casually know of the character and want to know more about him, the film trilogy does a great job of diving into the Wolverine’s life. 39. The Future of Health and Entertainment: Technology Benefits Amidst the Pandemic The world presently faces a huge healthcare crisis, in managing the coronavirus. So, it is only ideal to talk about healthcare solutions. However, when a virus is sweeping through the world is not the best time to discuss a 'trivial' issue such as entertainment. More so, where is the connection between the two? 40. 5 Blockchain Games and NFT Projects Taking Over Art and Entertainment NFTs are becoming mainstream due to recent innovations. Non-fungible tokens, better known as NFTs, are taking the blockchain, collectibles, and investment world 41. The Best films of 2022 that Everyone Must Watch We are fast approaching the end of 2022 and this would be the best time to recap the best movies this year. 42. How Can Your Lighting Affect On Watching TV Reflections on your TV’s screen will destroy any TV watching experience. By investigating room lighting factors which can influence the nature of TV seeing, you can improve your circumstance so you don’t need to manage a below average encounter. 43. A New Direction for Netflix? Read this post to get insight into the deal between Netflix and major movie theaters to exhibit "Glass Onion: A Knives Out Mystery" in November 2022. 44. Amazon, MGM, and the Triumph of New Hollywood Read this post for insight into how the rise of Amazon and the fall of MGM signals the triumph of New Hollywood. 45. The Thor Movies in Order Here are all of the Thor movies in order.  Starting from Thor all the way to Thor: Love and Thunder 46. All DC Movies Coming Out in 2023 Here are the DC movies coming out in 2023: Shazam, The Flash, Blue Beetle, and Aquaman. 47. The Noonification: From the Ocean’s Depths (9/17/2022) 9/17/2022: Top 5 stories on the Hackernoon homepage! 48. Emergent Entertainment Merger to Offer Next Generation of Digital and Immersive Entertainment Emergent Entertainment officially merges London-based video game studio Maze Theory with blockchain veterans and developers Pluto Digital PLC. 49. Every DC Movie That Got Canceled in 2022 Here are all of the DC films that were canceled in 2022: Batgirl, Man of Steel 2, Wonder Woman 3, and a Black Adam sequel. 50. Automatic for the People: Why Netflix Is at the Center of a Fight Between Artists and Audiences Netflix may well be a haven for original voices in filmmaking. But recently Netflix also alienated artists by testing a feature that would allow viewers to adjust the playback speed of the content they watch. As first reported in Android Police, the feature, known as variable playback speed, is being tested with a small group of Netflix customers who use Android devices. Variable playback speed would make it possible for viewers to reduce the speed of content to 0.5x or 0.75x or accelerate the speed to 1.25x or 1.5x. 51. Fictitious Works Disclaimer Notice: If You Have to Use One, Use This One A “Works of Fiction Disclaimer” that embodies the concept of having some entertainment value in addition to its desired “suitability to purpose”: 52. Will New Hollywood Save Old Hollywood? Read this article for insight how New Hollywood streaming companies could help Old Hollywood by releasing films in theaters. 53. How to Build a User-Creator Affinity Model for a Short Video Platform Build a recommendation system on a short-video platform that takes into account user-creator affinity. 54. Pornhub and The Adult Entertainment Industry Helped Shape The Internet The world as we know it would not have been possible without the influence of porn. In fact, the adult industry shaped today's technological advancements. 55. Ye’s Online Warfare: Dangerous or Comical? In this slogging thread, we discuss whether or not we, as a society, enable violent behavior just because it is entertaining and trending. 56. The Highest Grossing Movie of All Time Is Set to Release a Sequel The Highest Grossing Movie of all time, Avatar: The way of life is set to release a Sequel. 57. Why Warner Brothers Has Gone New Hollywood You could have seen this coming. 58. If Glitch Tech is Any Indication, the Nickelodeon and Netflix Partnership is a Winning Deal (Photo used with permission from Eric Robles and Dan Milano) 59. 10 Best Mario Kart Games of All Time Ranked by Sales Mario Kart is possibly one of the most lucrative franchises out there. Even a popular series like Animal Crossing can’t compare when it comes to overall sales. These simple, fun kart-driving games have placed millions of families in unending joy and emotional turmoil as they battle in races for first place. It’s especially interesting to look at all Mario Kart games ranked by how many copies each one sold, since there are many different aspects that might determine just why each title reached its own level of success. 60. Smart homes are getting mainstream: 85% of Americans bought a smart device in 2020 According to the Safewise study, 85% of Americans bought a smart home device in 2020, and three-quarters of them were 44 or younger. 61. What are the Best Battle Scenes in Movies? In this Slogging thread, the movie geeks at Hackernoon discuss the best battle scenes in movies. We talk about our favourite alongside our love for certain movi 62. What are the Best Telltale Games? Wolf Among Us, The Walking Dead Season 1, and Game of Thrones are among the best games from acclaimed developer Telltale Games. 63. Metavertainment: A Vision Into The World of The Metaverse and Entertainment The world of the metaverse and the world of entertainment are two fun worldsWhat wonders can happen when both worlds merge to become one fun-filled world? 64. Why New Hollywood Is Winning During the Pandemic Remember when Old Hollywood thumbed its nose at Netflix for skipping a wide theatrical release with The Irishman in 2019? No one is scorning Netflix or any of the streaming services anymore. The COVID-19 pandemic has upended the Old Hollywood distribution system. Movie theaters around the world are teetering on the edge of collapse because of declining attendance and closures during lockdowns. As a result, studios are denied an essential revenue stream to recoup the cost of making films that they’d already teed up for release in 2020 – with No Time to Die and Wonder Woman 1984 being two notable examples. 65. Understanding How Netflix Business Works Through Binge-Watching Binge-watching is the practice of watching TV series all at once. In a speech at the Edinburgh Television Festival in 2013, Kevin Spacey said: “If they want to binge then we should let them binge.” This new content format would be popularized by Netflix, launching its TV series all at once. 66. Why Netflix’s Squid Game is NOT Close to Reality I'm not thrilled, and I'm far away from being obsessed with Netflix's Squid Game. 67. Why Apple's Win at the 2022 Oscars is a Win for New Hollywood Read this post for insight into why Apple's victory at the 2022 Oscars is a win for all the New Hollywood streaming companies -- and a sign of Oscar's demise. 68. 9 Stories that Made us Cry (Slogging Insights) In this thread, we talk about the books, movies, or tv shows that were powerful enough to make us cry. 69. Entertainment Industry Tapping into Crypto's Vast Potential Is there any way to adopt crypto as a method of payment for the entertainment industry? If yes, what are the advantages and pitfalls? 70. What the Amazon/NFL Deal Means for New Hollywood The NFL officially joined the streaming era through a $13 billion deal with Amazon in which TNF games air on Amazon Prime. Here's what this moment means. 71. Fullmetal Alchemist: Brotherhood - The Pursuit of Happiness Fullmetal Alchemist: Brotherhood touches on themes of family, sacrifice, morality, and the consequences of power. 72. Welcome to New Hollywood New Hollywood has arrived. 73. How Data Science is Changing Media, Advertising, and Entertainment In advance of our upcoming event - Data Science Salon: Applying AI and ML to Media, Advertising, and Entertainment, we asked our speakers, who are some of nation’s leading data scientists in the media, advertising, and entertainment industries, to answer a few of our most pressing questions about the future of their industries. 74. 10 Movie Tie-In Games That Were Actually Good While they are now a thing of the past, it's worth celebrating and remembering these 10 movie tie-in games that were actually good. 75. Disney Doubles Down on Content to Save Its Future It's often said that content is king. For Disney, content is a savior. That’s the takeaway from Disney’s earnings report for the fiscal year and fourth quarter of 2020. 76. How Snoop Dogg Masters the Metaverse Read this post for insight into how music mogul Snoop Dogg is mastering the metaverse with a vertically integrated music business. 77. The Lord of the Rings TV Show Releases First Trailer In this slogging thread, we analyse the recent trailer for the lord of the rings TV show on Amazon. 78. 4 Ways to Acquire Customers as a Sports Betting Business Are you trying to enter the sports betting market? Find out the best-performing strategies for attracting new fans to your sportsbook. 79. Will Disney+ Create Magic through Profitable Content and Commerce? Read this post for insight into two keys to the future of Disney+ and New Hollywood: content and commerce. 80. What are the Best Comedy Movies of the 21st Century? In this slogging post, the team at Hackernoon discusses the best comedy movies of the 21st century. 81. What Does the Future Hold for the New Hollywood Streaming Industry? Where is the New Hollywood streaming industry headed after a wild and crazy 2022 thus far? Read this new post for insight into what to expect from this industry 82. Is the New Spiderman Movie any Good? In this slogging thread, our community discusses their opinions on the new spiderman movie, the new Marvel generation, and the future of superhero movies. 83. 10 Best Games on Xbox Game Pass in 2022 Xbox Game Pass is constantly evolving. In this article, we'll talk about some of the best games on Xbox Game Pass in 2022 to help you find titles you'll love. Thank you for checking out the 83 most read stories about Entertainment on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

Stories, News & Mentions about SAFEMINE

Safemine’s Stories on HackerNoon