DEV Community: Emanuel Ferreira

How to integrate a GitHub Repository with Large Language Models (LLMs)

Emanuel Ferreira — Wed, 27 Sep 2023 13:40:00 +0000

In this guide, we will explore how to combine the capabilities of AI with your GitHub repository, allowing you to query your codebase efficiently.

Prerequisites:

Ensure you have the pickle, os, and llama_hub libraries installed.
Get your API keys ready for both OpenAI and GitHub.

Step-by-Step Guide:

1. Environment and Library Initialization:

Start by importing necessary libraries.

import pickle
import os

2. Configuring OpenAI:

Before diving deep, you need to set the API key for OpenAI.

os.environ["OPENAI_API_KEY"] = "<YOUR_OPENAI_API_KEY>"

3. Load Llama Index:

The Llama Index is responsible for fetching and indexing data. Ensure you've downloaded the loader for the Github repository.

from llama_index import download_loader, GPTVectorStoreIndex
download_loader("GithubRepositoryReader")

4. Setting Up the GitHub Client:

For connecting with your GitHub repository, initialize the GitHub client.

from llama_hub.github_repo import GithubClient, GithubRepositoryReader

5. Fetching Repository Data:

Use the GitHub client to fetch the data from your repository. Here, we focus on the repository sec-insights owned by Llama Index team, specifically extracting Python files from the backend directory.

# File path and parameters
file_path = "docs.pkl"
github_personal_key = "<YOUR_GITHUB_PERSONAL_KEY>"
repository_owner = "run-llama"
repository_name = "sec-insights"
directories_to_include = ["backend"]
file_extensions_to_include = [".py"]
github_branch = "main"

# Load existing data if file exists
docs = None
if os.path.exists(file_path):
    with open(file_path, "rb") as f:
        docs = pickle.load(f)

# If data not loaded, fetch from GitHub and save
if docs is None:
    github_client = GithubClient(github_personal_key)
    loader = GithubRepositoryReader(
        github_client,
        owner=repository_owner,
        repo=repository_name,
        filter_directories=(directories_to_include, GithubRepositoryReader.FilterType.INCLUDE),
        filter_file_extensions=(file_extensions_to_include, GithubRepositoryReader.FilterType.INCLUDE),
        verbose=True,
        concurrent_requests=10,
    )
    docs = loader.load_data(branch=github_branch)

    # Save fetched data for future use
    with open(file_path, "wb") as f:
        pickle.dump(docs, f)

6. Indexing Data

Once your data is fetched, it's time to employ the powers of AI. We use the GPTVectorStoreIndex to index our documents. This tool converts our documents into vectors which can be efficiently searched later.

index = GPTVectorStoreIndex.from_documents(docs)

7. Querying Your Repository:

With everything in place, you can now query your indexed data. For example, to gain insights into your API endpoints, simply execute:

query_engine = index.as_query_engine()
response = query_engine.query("Retrieve all API endpoints")

print(response)

Security

When working with OpenAI APIs, it's important to understand that your data will be processed and enhanced through their systems. If security is a concern, consider switching to local models like llama.cpp and Hugging Face embeddings.

Using these local solutions ensures your data remains within your infrastructure. Just ensure your hardware is up to the task to efficiently handle these models.

Conclusion:

By integrating AI capabilities with your GitHub repository, you can derive insights, query specific parts of your codebase, and enhance your development workflow. It's a leap towards smarter code management and comprehension.

Remember to keep your API keys confidential and adjust the repository specifics to your needs. Happy coding!

Do you want to discuss AI or Startups? DM me on X(previously Twitter) or LinkedIn

References

https://github.com/EmanuelCampos/gh-index
https://llamahub.ai/l/github_repo
https://gpt-index.readthedocs.io/

Understanding Retrieval Augmentation Generation (RAG) Behind llama-index for Beginners

Emanuel Ferreira — Tue, 06 Jun 2023 11:04:55 +0000

Large Language Models (LLMs) like GPT and Llama only have access to public data, making it hard for enterprises to use their own private data to build Artificial Intelligence (AI) products.

A cheap and fast way to get around this issue with LLMs is using Context Augmentation, where you can augment LLMs with your private data.

In this article, we will see behind LlamaIndex which is a data framework for LLMs applications

Context Augmentation

Context augmentation is when you provide data to your context window (a range of tokens that the model considers when generating responses to prompts) when synthesizing an answer to a query with the LLM.

Let's suppose you want to ask a question about how to be rich to LLM based on your own private data.

Using LlamaIndex, under the hood, it would look like this:



context_str = 'a text about how to be rich'
query_str = 'how to be rich creating business?'



DEFAULT_TEXT_QA_PROMPT_TMPL = (
    "Context information is below. \n"
    "---------------------\n"
    "{context_str}"
    "\n---------------------\n"
    "Given the context information and no prior knowledge, "
    "answer the question: {query_str}\n"
)



# output: do x, y

Together with your question query_str, LlamaIndex will send your extra context to the LLM under context_str variable, creating a response that is grounded in the data you have provided.

Dealing with large contexts

Sometimes context doesn't fit in a single LLM call due to token limits. To solve this, LlamaIndex refines answers across multiple LLM calls, breaking the original context into multiple chunks, and using the new context chunks in each iteration with the refine template.



context_str = 'second part about how to be rich'
query_str = 'how to be rich creating business?'
existing_answer = 'do x, y'



CHAT_REFINE_PROMPT_TMPL_MSGS = [
    HumanMessagePromptTemplate.from_template("{query_str}"),
    AIMessagePromptTemplate.from_template("{existing_answer}"),
    HumanMessagePromptTemplate.from_template(
        "We have the opportunity to refine the above answer "
        "(only if needed) with some more context below.\n"
        "------------\n"
        "{context_msg}\n"
        "------------\n"
        "Given the new context, refine the original answer to better "
        "answer the question. "
        "If the context isn't useful, output the original answer again.",
    ),
]



# output: do x, y, z

After each iteration, the answer will be refined again and again, getting better until the refinement stops. This way, the LLM has a chance to read all the context before providing a final answer.

Conclusion

That's the core part of context augmentation for beginners. Behind the scenes, there are a lot of techniques to make it more performant and precise, such as top_k similarity, vector stores, and prompts optimizations.

What's next

A great start is a repository that I did. There you can get your favorite essays through a crawler and augment LLMs based on your favorite authors

https://github.com/EmanuelCampos/monorepo-llama-index

Wanna discuss AI, Technology, or startups? DM me on Twitter or LinkedIn

Thanks to the reviewers:

Logan Markewich - Software Engineer at LLamaIndex

References:

Context Window - Chelsy Ma
LLamaIndex

How I built a Bitcoin indexer using ZeroMQ

Emanuel Ferreira — Fri, 04 Nov 2022 18:29:55 +0000

Indexers are node operators that fetch data from a node then transform it and store on a database to provide easy access to the blockchain data. You can use it to build a history of user's transactions, or get a transaction/block to build a decentralized application.

ZeroMQ is an open source messaging library that you can connect and use some socket patterns. We will use a pub-sub pattern to subscribe on the node and listen new blocks and transactions on real time to store on our database and have a fast access than accessing directly the blockchain, and have a easy way to scale it.

Bitcoind is a node interacting who will allow us to interact with the blockchain and get the desired data.

Subscribing to Bitcoind using ZeroMQ

To Listen to new blocks and transactions you need to run a node locally on your own infrastructure, you can download bitcoind here

Using ZeroMQ you can set a address to publish your events (blocks and transactions) then on each new event your node emit and the application can deal with it.

To run a node with ZeroMQ using bitcoind:

bitcoind -signet -zmqpubrawblock=tcp://127.0.0.1:3000 -zmqpubrawtx=tcp://127.0.0.1:3000

After run the node, you can install zeromq package and listen rawblock and rawtx event, then insert on your database.

import zmq from "zeromq";

const SOCKET_ADDRESS = "tcp://127.0.0.1:3000"

const connectZeroMQ = () => {
    const socket = zmq.socket('sub');
    socket.connect(SOCKET_ADDRESS);
    socket.subscribe('');
    return socket;
}

const zmq = connectZeroMQ();

zmq.on('rawblock', (error, block) => {
    if(err !== null) return;
    // parse and store on your database
})

zmq.on('rawtxn', (error, txn) => {
    if(err !== null) return;
    // parse and store on your database
})

Conclusion

You can achieve this result on different ways, but ZeroMQ gives to you more security and reliability to receive the blocks and transactions on real-time, this code can be used in production, but I highly recommend that you create a script to check every block and transaction from time to time to make sure none are lost.

In my repository below you can find all the code above connected to the database, and getting the lost blocks, or old blocks, feel free to contribute =)
https://github.com/EmanuelCampos/bitcoin-indexer

If you have some suggestions/feedbacks you can call me on:
Twitter

Should I use database index or not?

Emanuel Ferreira — Tue, 27 Sep 2022 10:25:09 +0000

Indexes are a database structure to efficiently optimize your queries. A pointer is created to quickly find data instead of scanning your entire collection/table.

However, you need to know when to use or which type of index to optimize your queries.

Just as this can speed up your queries, it can slow down your entire database and increase the maintenance cost. Poorly chosen indexes decrease your performance by having to restructure all your B-tree

When to use an Index?

Analyzing your application is essential when choosing an index, which queries are being hit mostly? Does this one need to be faster? Will you give up inserting/updating speed to save time on readings?

Selecting Indexes that will be used in many queries will help your index be more accurate and performant.

Indexes should be used where you need to do a lot of reading operations on larger collections/tables or in searches that need to be fast.

When to not use an Index?

When your database has a lot of writes and read operations in indexed fields might be a lot expensive since your database will have to rewrite all your indexes.

For each writing operation, you are writing 2 times in your database, once the data and another for the index, taking up disk space and consuming more hardware to maintain the same, in large amounts slowing down your database.

Modeling your database by thinking about the number of writes operations that it will have, whether INSERT, DELETE, or UPDATE will save you a lot of headaches if you need fast READ operations.

Analyzing when you need fast insertions also will help you optimize your perfomance.

Conclusion

Choosing an index is not as easy as it seems, knowing how to analyze your indexes is an essential step to doing something performant, but when well chosen this will certainly optimize your queries.

Feedbacks on Twitter

How to create a smart contract to whitelist users

Emanuel Ferreira — Tue, 14 Dec 2021 13:10:30 +0000

Overview

In this article, we going to create a smart contract to whitelist users, that it will be possible to add an address, check a user, and verify each function if the user has been whitelisted.

Prerequisites

Code Editor (Remix, VSCode)
Basic Solidity Knowledge

Remix Editor

To create the smart contract we are going to use the Remix editor that will help us to create our smart contract.

Ownable contract

First, we'll start with the basic structure of a contract, we are going to create a contract Ownable.

Setting the contract owner

To whitelist the users we need to have a contract owner that will have permission to add users to the whitelist

Now create a variable called owner and add the deployer address as the owner of the contract

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

contract Whitelist {

    address owner; // variable that will contain the address of the contract deployer

    constructor() {
        owner = msg.sender; // setting the owner the contract deployer
    }

}

Create the Modifier

The modifier will help us when we need to restrict a function to only the owner of the contract to use.

modifier onlyOwner() {
    require(msg.sender == owner, "Ownable: caller is not the owner");
    _;
}

Now when you try to call a function that contains the onlyOwner modifier just will work if you are the contract owner

Create a list of addresses

To store our addresses, we need to create a mapping that will receive the address of the user and return if he is whitelisted or not.

mapping(address => bool) whitelistedAddresses;

Now you can store the addresses in the whitelistedAddresses mapping, Let's do it in the next steps.

Adding an address to the whitelist

Now we'll manipulate the whitelistedAddresses mapping to say if the address is whitelisted or not, so when we call the addUser function we'll change the whitelisted status from the address to true.

function addUser(address _addressToWhitelist) public onlyOwner {
    whitelistedAddresses[_addressToWhitelist] = true;
}

You can see that we have the onlyOwner modifier in our function, so just the contract owner can call this function.

We have the parameter _addressToWhitelist that is the address of a user that we want to whitelist.

So in this line, we are changing the status of the address to true.

true = whitelisted
false = not whitelisted

whitelistedAddresses[_addressToWhitelist] = true;

Verifying if the user has been whitelisted

Now create a function that will say to you if the user has been whitelisted (you don't need a function, you can access the list in another function or create a modifier to verify).

function verifyUser(address _whitelistedAddress) public view returns(bool) {
    bool userIsWhitelisted = whitelistedAddresses[_whitelistedAddress];
    return userIsWhitelisted;
}

So when you call this function it will return false if the address has not whitelisted and true if you added the user to the whitelist

Creating a modifier to whitelisted users

If you want to allow only the whitelisted addresses to call a function you can create a modifier.

So Let's create a modifier and a function to test example

modifier isWhitelisted(address _address) {
  require(whitelistedAddresses[_address], "You need to be whitelisted");
  _;
}

function exampleFunction() public view isWhitelisted(msg.sender) returns(bool){
  return (true);
}

Then our modifier will verify in the whitelisted addresses if the user (msg.sender) is whitelisted and still following with the function or break returning an error.

Conclusion

Now your contract to add users to the whitelist is done, you can adapt it to our projects like NFT collections verifying if the address is whitelisted to mint the NFTs.

Repository with the Project (Final code): https://github.com/EmanuelCampos/whitelist_contract
Stars are appreciated <3

Follow me on Twitter

How to mint 10000 NFTs on Opensea

Emanuel Ferreira — Thu, 28 Oct 2021 14:49:47 +0000

Minting to Opensea

After creating all your NFTs the more hardest step is to mint so many NFTs to Opensea mostly in large quantities without a contract.

To do it I'll share my repository that uses puppeteer to automate the process of minting the NFTs, you just need an images folder file and the images name to mint all. I'll teach you how to use the repository below.

If you want to add another property on the mint time send me an email we can discuss it oi@manel.dev.

Install the packages

To start we go to install the packages to run the script, on your project run:

yarn add @chainsafe/dappeteer puppeteer esbuild esbuild-register

The @chainsafe/dappeteer serves to automate the metamask connect to mint the NFTs.

The puppeteer we will use to upload the images and fill the inputs.

And we are going to use the esbuild and esbuild-register to run our script.

Create the script

Let's start creating a file called script.ts file doing the first imports and adding your first variables.

script.ts

import puppeteer, { Page } from 'puppeteer';
import dappeteer from '@chainsafe/dappeteer';
import fs from 'fs';

const collectionName = "Your Collection Name"
const collectionURL = `https://opensea.io/collection/${collectionName}/assets/create`
const openseaDescription = `Your description here`
const lockedContent = `Locked content text here`

Connect Wallet Function

So to select the Metamask wallet when our script opens the Browser, let's create a function to click on the Metamask button and connect to the wallet.

script.ts

const connectWallet = async (page: Page, metamask) => {
  const button = await page.$('button.dBFmez:first-child');
  await button.click();

  await metamask.approve();

  return;
}

Create the Upload Image function

Now to upload the image on create NFT page let's create the function which receives the page and the file then takes the input element in the HTML and uploads the image to it.

script.ts

const uploadImage = async (page: Page, file: string) => {
  const elementHandle = await page.$("#media");
  await elementHandle.uploadFile(`images/${file}`);

  return;
}

Create the page timeout function

This function is to give time for our script to perform the filling or clicks in the application.

script.ts

const pageTimeout = async (time: number, page: Page) => {
  await page.waitForTimeout(time)
  return;
}

Create the fill fields function

this is the function where we are going to get each field from the create NFT page and fill it.

the steps this function takes
1- Fill in the field name
2 - Fill in the field input.
3 - Turn on the unlockable content and fill the unlockable content text.
4 - Select the Polygon chain

script.ts


const fillFields = async (page: Page, fileName: string) => {

// Get and fill in the input name
  await page.focus('#name')
  await page.keyboard.type(fileName)

  await pageTimeout(1000, page)

//Get and fill in the input name
  await page.$eval('#description', (el, value) => el.value = value, openseaDescription);
  await page.focus('#description')
  await page.keyboard.type(' ')

  await pageTimeout(1000, page)

// Click on the unlockable content checkbox
  await page.evaluate(() => {
    document.querySelector("#unlockable-content-toggle").parentElement.click();
  });

  await pageTimeout(1000, page)

// Fill in the unlockable content text
  await page.$eval('textarea[placeholder="Enter content (access key, code to redeem, link to a file, etc.)"]', (el, value) => el.value = value, lockedContent);
  await page.focus('textarea[placeholder="Enter content (access key, code to redeem, link to a file, etc.)"]')
  await page.keyboard.type(' ')

// Open the select chain input
  const input = await page.$("#chain")
  input.click()

  await pageTimeout(1000, page)

// Select the polygon chain
  await page.click('img[src="/static/images/logos/polygon.svg"]')

  return;
}

Creating the Main Function

In this function we go to create all the main functions to run our scripts the steps are:

1 - Run the dappeteer to set up the Metamask on Opensea.
2 - Get our files from the images folder file.
3 - Remove the first file(.DS_Store) - just for macOS.
4 - Open the create asset page of the collection.
5 - Run the connect wallet function
6 - Run a loop for each image on the images folder (to create the asset one by one)

See the code below step-by-step:

script.ts

(async () => { // Async function because we need promises to do it
  const browser = await dappeteer.launch(puppeteer, { metamaskVersion: 'v10.1.1' }); // Launch the browser with metamask
  const metamask = await dappeteer.setupMetamask(browser, { seed: "Secret phase here"}); // Add your secret phase here to metamask connect with your account
  const files = await fs.promises.readdir("images/"); // Get an List with all images on images folder
  files.shift() // WARN: just on macOS: remove the first file .DS_Store 

// Open the create assets url of the  collection
  const page = await browser.newPage();
  await page.goto(collectionURL);

// Get the tabs and close the first tab openned by the dappeteer
  const firstTabs = await browser.pages()
  await firstTabs[0].close()

  await pageTimeout(2000, page)

// Run our function to click on the Metamask button in the Opensea
  await connectWallet(page, metamask)

// Start the loop on each image of images folder
  for (let i = 0; i <= files.length ; i++) {
    const tabs = await browser.pages() // Get the tabs on each loop
    const data = {
      name: `Your Asset name here #${1 + i}`, // Add your NFT name (the count start on 1 and stop on the quantity of the files)
    }

// At the first time on loop you need to do an sign to create the assets 
    if(i === 0) {
      await tabs[1].bringToFront() // Move one tab
      await tabs[1].goto(collectionURL) // Change the page to collection url again

      await pageTimeout(2000, page)

      await metamask.sign() // Use the metamask to do the transaction
      await metamask.page.waitForTimeout(2000) // wait for the transaction
    }

// Now if not the first time, after creating the first NFT just open the create assets page again to create the second NFT and so sequentially.
    if(i === 0) {
      await tabs[1].bringToFront()
      await tabs[1].goto(collectionURL)
    } else {
      await tabs[1].bringToFront()
      await tabs[1].goto(collectionURL)
    }

    await pageTimeout(2000, page)

// Upload the current image file
    await uploadImage(page, files[i]);

// Fill the fields using the asset name with the count
    await fillFields(page, data.name);

// Click on create asset button
    const button = await page.$('.AssetForm--action button');
    await button.click()

    await pageTimeout(4000, page)

// Rename the image name to know if already is completed
    fs.renameSync(`images/${files[i]}`, `images/completed-${files[i]}`)

    console.log({ message: `Mint the NFT: ${data.name}`, fileName: files[i]})
    console.log(`Mint the NFT: ${data.name}`)
  }

  console.log('Minted all NFTs with success')
})();

Ready!! now Let's config our package.json to run the script with one line

package.json

{
  "name": "node",
  "version": "1.0.0",
  "main": "index.js",
  "license": "MIT",
  "dependencies": {
    "@chainsafe/dappeteer": "^2.2.0",
    "dappeteer": "^1.0.0",
    "esbuild": "^0.13.10",
    "esbuild-register": "^3.0.0",
    "puppeteer": "^10.4.0"
  },
  "scripts": {
    "es": "node -r esbuild-register"
  }
}

Now to run your script just run on the CLI:

yarn es ./src/script.ts

Download the Repository

First, you need to download my repository here that contains the script to mint the NFTs.

Star my repository here

It's done, now the puppeteer will create all your NFTs one by one and so much fast.

That's it!!

Follow me on Twitter
My Github

How to mint an NFT via CLI

Emanuel Ferreira — Mon, 20 Sep 2021 10:26:34 +0000

Introduction

In this article we will create a script with NodeJS to create an NFT via CLI, passing in its private address and a URL containing the NFT metadata.

To do this tutorial, I recommend looking at our series to understand the previous steps and see how we got here

How to create a Smart Contract to mint an NFT

How to deploy a Smart Contract to Rinkeby Testnet using Infura and Hardhat

Boilerplate

To be faster, I will provide a boilerplate containing the babel, typescript, file structure, packages, scripts, environment variables...

Click here to go to the GitHub with boilerplate

Our boilerplate contains the following packages to run the script:

Taking the Provider

Our application provider will help us interact with our contract by defining the network we want to access as mainnet or testnet.

Note: To get the provider we are going to use Infura, you can see my previous article on how to use Infura: How to deploy a Smart Contract to Rinkeby Testnet using Infura and Hardhat

Going into the getProvider file in the src/getProvider.ts directory we will take the code below and edit it to get our provider.

getProvider.ts

import { ethers } from "ethers"; //Library to connect to the ethereum
import dotenv from 'dotenv' // Library to get the enviroment variables

dotenv.config() // starting the dotenv

export const getProvider = () => {
}; // function to get provider

Now we are going to edit our file and leave it the same as below(I will explain in the code what each line does).

getProvider.ts

import { ethers } from "ethers";
import dotenv from 'dotenv'

dotenv.config()

export const getProvider = () => {
  const infuraProvider = new ethers.providers.InfuraProvider(
    process.env.NETWORK, // Our enviroment variable with network (rinkeby, mainnet, ropsten)
    process.env.PROJECT_ID // Our environment variable with the id of our project in infura
  ); // Function in ethers to connect to Infura

  return infuraProvider; // returning the provider
};

Ready, we finished our first function!

Contract Addresses

In the contractAddresses.ts file in src/contractAddresses.ts we have an export of the environment variable which is the address of the contract we deployed in the previous article.

contractAddresses.ts

import dotenv from 'dotenv'

dotenv.config()

export const FactoryNFTAddress = process.env.CONTRACT_ADDRESS;

Creating the Mint Script

Now finally let's create our script to mint an NFT using only 1 command.

We have some basic settings to run our script:

In the mintNFT.ts file in src/mintNFT.ts we have some basic settings to run our script, let's complete by adding the desired functions.

mintNFT.ts

import { ethers } from "ethers";

const run = async () => {
};

(async () => {
  try {
    await run();
  } catch (err) {
    // eslint-disable-next-line
    console.log("err: ", err);
    process.exit(1);
  }
  process.exit(0);
})();

Getting the args

Let's start by getting the two arguments that are privateKey and tokenURI and validating if at least 2 arguments were sent.

mintNFT.ts

import { ethers } from "ethers";

const run = async () => {
  const [, , ...unsanitizedArgs] = process.argv; // getting the args

  if (unsanitizedArgs.length !== 2) {
    // eslint-disable-next-line
    console.log("yarn es ./src/mintNft <privatekey> <tokenuri>");
    return;
  } // validating whether the 2 arguments were sent

  const [privateKey, tokenUri] = unsanitizedArgs; // destructuring to get the arguments


};

(async () => {
  try {
    await run();
  } catch (err) {
    // eslint-disable-next-line
    console.log("err: ", err);
    process.exit(1);
  }
  process.exit(0);
})();

Getting the Provider

After we get the arguments we need to know which address is being used to mint the NFT and sign the contract.

mintNFT.ts

import { ethers } from "ethers";

const run = async () => {
  const [, , ...unsanitizedArgs] = process.argv; // getting the args

  if (unsanitizedArgs.length !== 2) {
    // eslint-disable-next-line
    console.log("yarn es ./src/mintNft <privatekey> <tokenuri>");
    return;
  } // validating whether the 2 arguments were sent

  const [privateKey, tokenUri] = unsanitizedArgs; // destructuring to get the arguments
};

(async () => {
  try {
    await run();
  } catch (err) {
    // eslint-disable-next-line
    console.log("err: ", err);
    process.exit(1);
  }
  process.exit(0);
})();

Connecting with the wallet and the contract

First, we need to import some things which are the ABI of our contract that we got after compiling it, the address of our contract, and our getProvider

mintNFT.ts

import { ethers } from "ethers";
import { getProvider } from "./getProvider";

import FactoryNFT from "../artifacts/contracts/factoryNFT.sol/FactoryNFT.json";
import { FactoryNFTAddress } from "./contractAddresses";


const run = async () => {
  const [, , ...unsanitizedArgs] = process.argv; // getting the args

  if (unsanitizedArgs.length !== 2) {
    // eslint-disable-next-line
    console.log("yarn es ./src/mintNft <privatekey> <tokenuri>");
    return;
  } // validating whether the 2 arguments were sent

  const [privateKey, tokenUri] = unsanitizedArgs; // destructuring to get the arguments
};

(async () => {
  try {
    await run();
  } catch (err) {
    // eslint-disable-next-line
    console.log("err: ", err);
    process.exit(1);
  }
  process.exit(0);
})();

You can get your ABI contract after compiling your contract, just dragging the artifacts folder to the root folder.

Now we need to pass the wallet that we are using for our transaction to our contract, for that we will use ethers on both occasions.

mintNFT.ts

import { ethers } from "ethers";

const run = async () => {
  const [, , ...unsanitizedArgs] = process.argv; // getting the args

  if (unsanitizedArgs.length !== 2) {
    // eslint-disable-next-line
    console.log("yarn es ./src/mintNft <privatekey> <tokenuri>");
    return;
  } // validating whether the 2 arguments were sent

  const [privateKey, tokenUri] = unsanitizedArgs; // destructuring to get the arguments

  const wallet = new ethers.Wallet(privateKey, provider); // getting your wallet

  const factoryNFTContract = new ethers.Contract(
    FactoryNFTAddress, // your contract address
    FactoryNFT.abi, // your contract ABI
    wallet // your wallet
  ); // getting the contract
};

(async () => {
  try {
    await run();
  } catch (err) {
    // eslint-disable-next-line
    console.log("err: ", err);
    process.exit(1);
  }
  process.exit(0);
})();

Making the transaction

And now the last step is to use our contract to make our transaction.

mintNFT.ts

import { ethers } from "ethers";

const run = async () => {
  const [, , ...unsanitizedArgs] = process.argv; // getting the args

  if (unsanitizedArgs.length !== 2) {
    // eslint-disable-next-line
    console.log("yarn es ./src/mintNft <privatekey> <tokenuri>");
    return;
  } // validating whether the 2 arguments were sent

  const [privateKey, tokenUri] = unsanitizedArgs; // destructuring to get the arguments

  const wallet = new ethers.Wallet(privateKey, provider); // getting your wallet

  const factoryNFTContract = new ethers.Contract(
    FactoryNFTAddress, // your contract address
    FactoryNFT.abi, // your contract ABI
    wallet // your wallet
  ); // getting the contract
};

  console.log("minting");
  const transaction = await factoryNFTContract.createToken(tokenUri); // interacting with the contract
  const tx = await transaction.wait(); // waiting the minting of the block
  const event = tx.events[0];
  const value = event.args[2];
  const tokenId = value.toNumber(); // getting the created tokenId

  console.log({
    transaction,
    tx,
    tokenId,
  }); // returns

(async () => {
  try {
    await run();
  } catch (err) {
    // eslint-disable-next-line
    console.log("err: ", err);
    process.exit(1);
  }
  process.exit(0);
})();

Now you can run the command below and see the result in the console.

yarn es ./src/mintNft <privatekey> <tokenuri>

Result:

The script is done, now you can get your tokenID and consult the contract that will return your metadata.

thanks Sibelius for helping with the script.

Now you can Follow me on Twitter

Project Repository(Complete): https://github.com/EmanuelCampos/mint-nft-script/tree/master

Project Repository(Blank Template): https://github.com/EmanuelCampos/mint-nft-script/tree/boilerplate

How to deploy a Smart Contract to the Testnet

Emanuel Ferreira — Fri, 17 Sep 2021 11:54:02 +0000

In this article I will teach you how to deploy your contract to the Rinkeby Testnet.

To be faster we will use our project from another article: How to create a smart contract to mint an nft

Creating an account and an Ethereum project in Infura

Infura provides instant access over HTTPS and WebSockets to the Ethereum network.

Access Infura

Create your account (Common Steps).
Click Ethereum, then create new project.

Give a name for your project .
Save your project id.

Initial settings

Returning to the project, let's make the initial settings for our project.

Let's go to the hardhat.config.js file and add an object called network along with another object called rinkeby containing url and accounts.



require("@nomiclabs/hardhat-waffle");

/**
 * @type import('hardhat/config').HardhatUserConfig
 */

module.exports = {
  solidity: "0.8.3",
  networks: {
   rinkeby: {
     url: "", //Infura url with projectId
     accounts: [""] // add the account that will deploy the contract (private key)
    },
  }
};

Now in url we add the url with the project id provided by Infura and in accounts we add the private address of our wallet.

Note: Be careful with your private key, it gives access to your wallet and will spend its crypto to deploy the contract.



require("@nomiclabs/hardhat-waffle");

/**
 * @type import('hardhat/config').HardhatUserConfig
 */

module.exports = {
  solidity: "0.8.3",
  networks: {
   rinkeby: {
     url: "https://rinkeby.infura.io/v3/ba900937b83f4883b926713999277b1f", //Infura url with projectId
     accounts: ["123456789101112131415"] // add the account that will deploy the contract (private key)
    },
  }
};

Creating the script to deploy

Now to deploy the smart contract to rinkeby testnet, we are going to make a script with the hardhat that will make it easier for us to upload it with a command.

In the root directory, create a folder called scripts and inside a file called deploy.js



/node_modules
/contracts
/test
/scripts
 | - deploy.js
hardhat.config.js
package.json
yarn.lock

Now we're going to modify the file by adding the script below, where I'll explain it line by line.

deploy.js



const hre = require("hardhat"); //import the hardhat

async function main() {
  const [deployer] = await ethers.getSigners(); //get the account to deploy the contract

  console.log("Deploying contracts with the account:", deployer.address); 

  const FactoryNFT = await hre.ethers.getContractFactory("FactoryNFT"); // Getting the Contract
  const factoryNFT = await FactoryNFT.deploy(); //deploying the contract

  await factoryNFT.deployed(); // waiting for the contract to be deployed

  console.log("FactoryNFT deployed to:", factoryNFT.address); // Returning the contract address on the rinkeby
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  }); // Calling the function to deploy the contract

Now to deploy your contract just run this commands:



yarn compile



yarn hardhat run scripts/deploy.js --network rinkeby

result



Deploying contracts with the account: 0xAFEeb469Ce6376979Ea037b4CE6b7172f9018007
FactoryNFT deployed to: 0xF9e6b75cE8da147D4f1d7d2cc597A7A42A645006

Contract deployed!!!

Now you can Follow me on: Twitter
Project Repository: https://github.com/EmanuelCampos/mint-nft/tree/with-deploy-config

How to create a Smart Contract to mint an NFT

Emanuel Ferreira — Thu, 16 Sep 2021 15:33:02 +0000

In this article we are going to create a smart contract to mint an NFT on Ethereum.

Setup the project

To start the project we will use the hardhat that will provide us with a boilerplate to deploy the contract, do tests, etc.

Installing the hardhat

We will install hardhat as development dependency using the yarn.

Open a new terminal and run these commands:

mkdir nft-token
cd nft-token
yarn init -y
yarn add hardhat -D

In the same directory where you installed Hardhat run:

npx hardhat

Select Create an empty hardhat.config.js with your keyboard and hit enter.

888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

👷 Welcome to Hardhat v2.6.4 👷‍

? What do you want to do? … 
  Create a basic sample project
  Create an advanced sample project
❯ Create an empty hardhat.config.js
  Quit

Creating the files and directories

Let's start by creating a directory called contracts in the root folder.

/node_modules
/contracts
hardhat.config.js
package.json
yarn.lock

After creating the folder we can create our first file of our contract inside the directory, let's call it: factoryNFT.sol

/node_modules
/contracts
 | - factoryNFT.sol
hardhat.config.js
package.json
yarn.lock

Writing the smart contract

Now we go to the most anticipated part of the article, writing our contract.

Note: You can review the basics in my other article: How to create a smart contract to receive donations using Solidity

Let's start defining the pragma version:
factoryNFT.sol

pragma solidity ^0.8.3;

To help us, we will install the openzeppelin contracts package.

yarn add @openzeppelin/contracts  @openzeppelin/hardhat-upgrades

Now we can import it into the contract.

factoryNFT.sol

pragma solidity ^0.8.3;

import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

We made 3 imports:

Counters: is a useful one that will help us increment a tokenId for each new token.
ERC721URIStorage: we will provide some functions to handle our tokenURI, which contains metadata and image.

ERC721: will we provide some basic functions of the ERC721;

Inheriting the OpenZeppelin contract

Now we can start by defining the name of our contract and inheriting the OpenZeppelin contracts.

factoryNFT.sol

pragma solidity ^0.8.3;

import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract FactoryNFT is ERC721URIStorage { 

    using Counters for Counters.Counter; 
    Counters.Counter private _tokenIds;

    constructor() ERC721("Factory NFT", "FTN") {
    }
}

Creating our Mint function

Let's start by creating our function calling createToken, where it will receive as a parameter, our tokenURI.

factoryNFT.sol

pragma solidity ^0.8.3;

import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract FactoryNFT is ERC721URIStorage { 

    using Counters for Counters.Counter; 
    Counters.Counter private _tokenIds;

    constructor() ERC721("Factory NFT", "FTN") {
    }

    function createToken(string memory tokenURI) public returns (uint) {
    }
}

Now let's increment the amount of token in storage and save it in a variable.

factoryNFT.sol

pragma solidity ^0.8.3;

import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract FactoryNFT is ERC721URIStorage { 

    using Counters for Counters.Counter; 
    Counters.Counter private _tokenIds;

    constructor() ERC721("Factory NFT", "FTN") {
    }

    function createToken(string memory tokenURI) public returns (uint) {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();
    }
}

Now we can put the main function of the contract which is to mint our NFT and set its tokenURI.

factoryNFT.sol

pragma solidity ^0.8.3;

import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract FactoryNFT is ERC721URIStorage { 

    using Counters for Counters.Counter; 
    Counters.Counter private _tokenIds;

    constructor() ERC721("Factory NFT", "FTN") {
    }

    function createToken(string memory tokenURI) public returns (uint) {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();

        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }
}

Compiling and testing the Contract
Now to test the contract, we are going to compile it and write a test for it.

First of all let's go to the hardhat.config.js file and change the solidity version to ^0.8.3.

hardhat.config.js

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "^0.8.3",
};

Plugins

Now to test our contract we need to install some plugins for hardhat to help us interact with Ethereum and test our contracts.

yarn add -D @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai

After adding the plugins we need to add a line in hardhat.config.js to setup the plugins.

hardhat.config.js

require("@nomiclabs/hardhat-waffle");
/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "^0.8.3",
};

Writing the test

Now create a directory called test in the root folder and add called: factoryNFT.js

/node_modules
/contracts
/test
 |- factoryNFT.js
hardhat.config.js
package.json
yarn.lock

Now I am going to put the test below and explain each line to understand it.

const { expect } = require("chai");

describe("Minting the token and returning it", function () {
  it("should the contract be able to mint a function and return it", async function () {
    const metadata = "https://opensea-creatures-api.herokuapp.com/api/creature/1" //Random metadata url

    const FactoryContract = await ethers.getContractFactory("FactoryNFT"); // Getting the contract

    const factoryContract = await FactoryContract.deploy(); //Deploying the Contract

    const transaction = await factoryContract.createToken(metadata); // Minting the token
    const tx = await transaction.wait() // Waiting for the token to be minted

    const event = tx.events[0];
    const value = event.args[2];
    const tokenId = value.toNumber(); // Getting the tokenID

    const tokenURI = await factoryContract.tokenURI(tokenId) // Using the tokenURI from ERC721 to retrieve de metadata

    expect(tokenURI).to.be.equal(metadata); // Comparing and testing

  });
});

Now let's configure the package.json to run our script, add this script to your package.json to compile the contract.

  "scripts": {
    "compile": "yarn hardhat compile"
  }

package.json

{
  "name": "hardhat",
  "version": "1.0.0",
  "main": "index.js",
  "license": "MIT",
  "scripts": {
    "compile": "yarn hardhat compile"
  },
  "devDependencies": {
    "@nomiclabs/hardhat-ethers": "^2.0.2",
    "@nomiclabs/hardhat-waffle": "^2.0.1",
    "chai": "^4.3.4",
    "ethereum-waffle": "^3.4.0",
    "ethers": "^5.4.6",
    "hardhat": "^2.6.4"
  },
  "dependencies": {
    "@openzeppelin/contracts": "^4.3.2",
    "@openzeppelin/hardhat-upgrades": "^1.10.0"
  }
}

Now just compile and run the test and we will have the result!.

yarn compile
npx hardhat test

So we come to the end and you can see my next article on how to deploy to rinkeby testnet How to deploy smart contract to Rinkeby Testnet using Infura and Hardhat.

Repository: https://github.com/EmanuelCampos/mint-nft
Follow me on Twitter

How to create a smart contract to receive payments

Emanuel Ferreira — Sun, 05 Sep 2021 15:42:45 +0000

With the ascendancy of blockchains and cryptocurrencies you do not want to be left out of this right?

In this article I will teach to you how to create a smart contract to receive donations using solidity.

What is Solidity?

Solidity is an object-oriented programming language for writing smart contracts. It is used for implementing smart contracts on various blockchain platforms, most notably, Ethereum. Wikipedia

Pragma Version

First thing we will do after creating a .sol file(solidity extension) is define a pragma version, this is for solidity to understand which version our contract is in and to compile it correctly.

DonateContract.sol

pragma solidity ^0.8.0;

Starting the contract

Now we are going to start our contract, for this we need to call contract + ContractName for solidity to understand where our contract code will be.

DonateContract.sol

pragma solidity ^0.8.0;

contract DonateContract {
 //the code will stay here
}

Variables

Solidity supports three types of variables:

State variables: variables whose values are permanently stored in a contract storage.
Local variables: variables whose values are present till function is executing.
Global variables: special variables exists in the global namespace used to get information about the blockchain.

We are going to create two types of state variables:

The variables are written as follows: type + variableName

totalDonations: totalDonations is a uint that stores the amount of donations that have already been made.
owner: owner is of the payable address type that will be the creator of the contract that will receive the donations.

Obs: all addresses that will accept payment or make payment must be of the payable type.

DonateContract.sol

pragma solidity ^0.8.0;

contract DonateContract {

  uint totalDonations; // the amount of donations
  address payable owner; // contract creator's address

}

Using the constructor

In our solidity contract we have a constructor to set up our contract and set some standards.

We will define who will be the owner of our contract and that it will be of the payable type, in this case the creator of the contract.

DonateContract.sol

pragma solidity ^0.8.0;

contract DonateContract {

  uint totalDonations; // the amount of donations
  address payable owner; // contract creator's address

  //contract settings
  constructor() {
    owner = payable(msg.sender); // setting the contract creator
  }

}

Creating our first function

Now we are going to create a simple function to return the amount of donations.

DonateContract.sol

pragma solidity ^0.8.0;

contract DonateContract {

  uint totalDonations; // the amount of donations
  address payable owner; // contract creator's address

  //contract settings
  constructor() {
    owner = payable(msg.sender); // setting the contract creator
  }

  // public function to return the amount of donations
  function getTotalDonations() view public returns(uint) {
    return totalDonations;
  }
}

Our function takes three parameters:

public: This function is of the public type and can be called by anyone.
view: It means that this function is a view-only function and does not do any transactions and you don't need to pay gas to use it.
returns(uint): Here we are saying that the function will return something of type uint.

Creating function to make donation

Now we are going to make a function to make the donation, we need say that it is public and payable.

DonateContract.sol

pragma solidity ^0.8.0;

contract DonateContract {

  uint totalDonations; // the amount of donations
  address payable owner; // contract creator's address

  //contract settings
  constructor() {
    owner = payable(msg.sender); // setting the contract creator
  }

  //public function to make donate
  function donate() public payable {
    (bool success,) = owner.call{value: msg.value}("");
    require(success, "Failed to send money");
  }

  // public function to return total of donations
  function getTotalDonations() view public returns(uint) {
    return totalDonations;
  }
}

Obs: you can use nonReentrant to give more secure to your contract.

In our donate function we use owner.call{value: msg.value}("") to make a payment to owner of contract, where msg.value(global variable) is the value we want to send as a donation.

Then we get the call return to check if the transfer was successful using require.

The require takes as the first parameter the variable success saying whether a transaction was successful or not, thus returning an error or proceeding. The second parameter will be the message sent in case of error.

Ready!! we have our first contract ready. 😁🥳

For more content you can follow me here and on my twitter:
Twitter

MongoDB updateOne() , updateMany() e seus operadores

Emanuel Ferreira — Wed, 26 May 2021 14:11:29 +0000

Atualizando documentos

No MongoDB temos diversos métodos que nos ajudam a atualizar nossos documentos, por exemplo: adicionar um novo campo ou removê-lo e até adicionar um novo item em uma array ou remover.

Nesse artigo, vou mostrar alguns dos métodos que mais utilizo para atualizar documentos juntamente com alguns operadores de atualização. Vamos usar como exemplo o documento abaixo:

Nosso Documento

{
    "name": "Emanuel",
    "password": "123456",
    "email": "emanuel@gmail.com"
}

Métodos e Operadores

No MongoDB possuímos mais de 5 métodos que nos auxiliam na atualização de documentos, mas no nosso artigo iremos utilizar 2 em específico que são: updateOne e updateMany.

Ambos não retornam o documento, mas vou estar deixando o retorno para demonstração. Caso queira o retorno do documento utilize o método findOneAndUpdate.

Método updateOne

O método updateOne é responsável pela atualização de somente 1 documento. O método recebe 3 parâmetros que são: filter,
update e options que deixaremos para outro momento.

Exemplo

//filter => query do documento que deseja encontrar para alteração
//update => operador que irá utilizar na atualização do documento

const filter = { name: "Emanuel" }
const update = { $set: { name: "Rodrigo" } } //Abaixo explicaremos o que é o $set.

const user = db.users.updateOne(filter, update)

Retorno

{"name": "Rodrigo", "email": "emanuel@gmail.com", "password": "123456"}

Método updateMany

O método updateMany é responsável pela atualização de diversos documentos (muita atenção ao usar esse comando). Todos os documentos que forem encontrados de acordo com a query passada serão alterados.

Documentos de exemplo

{
    "name": "Emanuel",
    "password": "123456",
    "email": "emanuel@gmail.com",
    "genre": "male",
},
{
    "name": "Rodrigo",
    "password": "rodrigo123",
    "email": "rodrigo@gmail.com",
    "genre": "male"
}

Exemplo

const filter = { genre: "male" }
const update = { $set: { password: "123" } }
const user = db.users.updateMany(filter, update)

Retorno

[{"name": "Rodrigo", "email": "rodrigo@gmail.com", "password": "123", "genre": "male"}, {"name": "Emanuel", "email": "emanuel@gmail.com", "password": "123", "genre": "male"}]

Operadores de Atualização

Os métodos de atualização possuem diversos operadores de atualização que nos auxiliam na hora de atualizar um ou diversos documentos.
Na documentação você encontra diversos, mas vou estar deixando os que mais utilizo.

Exemplo de como utilizar um operador

db.users.updateMany(
{
 genre: "male"
},
{
  $set: { genre: "female", name: "Robson" },
  <operator2>: { <field2>: <value2>, ... },
  ...
}
)

Operador $set

Este operador é responsável por adicionar um novo campo no seu documento ou até a sobrepor um campo já existente.

Documento

{"name": "Rodrigo", "genre": "male"}

Exemplo

const user = db.users.updateMany({ name: "Rodrigo" }, { $set: { genre: "female" } })

Retorno

{"name": "Rodrigo", "genre": "female"}

Operador $inc

Este operador é responsável por incrementar ou decrementar um número ao campo (para decrementar só usar números negativos)

Documento

{"name": "Rodrigo", "seguidores": 10}

Exemplo

const user = db.users.updateOne({ name: "Rodrigo" }, { $inc: { seguidores: 2 } })

Retorno

{"name": "Rodrigo", "seguidores": 12}

Operador $push

Este operador é responsável por adicionar um novo item a uma array.

Documento

{"name": "Rodrigo", "interests": ["basquete"]}

Exemplo

const user = db.users.updateOne({ name: "Rodrigo" }, { $push: { interests: "futebol" } })

Retorno

{"name": "Rodrigo", "interests": ["basquete", "futebol"]}

Operador $pull

Este operador é responsável por remover um item da sua array.

Documento

{"name": "Rodrigo", "interests": ["basquete", "futebol"]}

Exemplo

const user = db.users.updateOne({ name: "Rodrigo" }, { $pull: { interests: "basquete" } })

Retorno

{"name": "Rodrigo", "interests": ["futebol"]}

Conclusão

Então, utilizamos o método updateOne quando queremos atualizar somente um documento e o método updateMany quando desejamos atualizar diversos documentos. Com o uso dos operadores certos, conseguimos resultados bem legais para suas alterações no banco.

Linkedin: Emanuel Ferreira
Email: contatoferreirads@gmail.com

Revisão do Texto: Ana Julia Lima

MongoDB, find() e findOne()

Emanuel Ferreira — Tue, 25 May 2021 18:45:07 +0000

Métodos

Para fazer uma busca por documento no MongoDB utilizamos os métodos find() e findOne(), que recebem dois tipos de parâmetro: a query, que irá fazer a busca no nosso banco de dados e o segundo parâmetro, que dizemos o que será retornado.

Nosso Documento

{
    "name": "Emanuel",
    "password": "123456",
    "email": "emanuel@gmail.com"
}

Exemplo do Comando

const query = { name: "Emanuel"}
const retorno = { name: 1, email: 1, password: 1}
const users = await db.users.find(query, retorno)

Método find

O Método find retorna uma array com todos os documentos que foram encontrados utilizando o campo name.

Query

const users = await db.users.find({ name: Emanuel })

Retorno

[{ "_id": 12345678, "name": "Emanuel", "password": "123456", "email": "emanuel@gmail.com"}]

Método findOne

O Método findOne retorna o primeiro documento que ele encontrar na collection que corresponda com o campo name.

Query

const users = await db.users.findOne({ name: "Emanuel" });

Retorno

{ "_id": 12345678, "name": "Emanuel", "password": "123456", "email": "emanuel@gmail.com"}

Como retornar campos específicos?

No MongoDB, quando desejamos retornar dados específicos de um documento, usamos um segundo parâmetro que é um objeto passando o nome do campo como chave e o valor sendo 0 ou 1.

Para cada campo que você deseja retornar do seu documento, você utiliza o dígito 1.

Após utilizar o dígito 1 você não pode utilizar o digito 0, que remove algum campo do retorno e vice-versa.

Exemplo com Dígito 1

Query

const users = await db.users.findOne({ name: "Emanuel" }, { name: 1, email: 1 });

Retorno

{"name" : "Emanuel", "email": "emanuel@gmail.com"}

Exemplo com Dígito 0

Query

const users = await db.users.findOne({ name: "Emanuel" }, { name: 0 });

Retorno

{"email": "emanuel@gmail.com", "password": "123456"}

Como buscar em campos aninhados?

Vamos supor que o seu documento siga o padrão abaixo:

{
    "interests": {
       "id": { type: String },
       "name": { type: String }
    }
}

Para acessar o campo id ou o campo name você pode utilizar:

Exemplo

const users = await db.users.findOne({ 'interests.name': "Emanuel" });

//Disponível apenas na versão 4.4 do MongoDB
const users = await db.users.findOne({ interests: { name: "Emanuel" }});

Retorno

{"name": "Emanuel", "email": "emanuel@gmail.com", "password": "123456"}

Conclusão

Então, utilizamos o método find quando desejamos retornar mais de um resultado e método findOne quando desejamos retornar somente um resultado. Assim, melhorando até a perfomance da query.

Linkedin: Emanuel Ferreira
Email: contatoferreirads@gmail.com

Revisão do Texto: Ana Julia Lima