The right way to Construct Dapps on Optimism in 5 Steps – Optimism API Information

In at this time’s article, we’ll present you the right way to construct dapps on Optimism with Moralis’ industry-leading Web3 API suite. With our premier improvement instruments, you’ll be able to seamlessly fetch and combine on-chain information into your Optimism initiatives with solely single traces of code. When you’re desirous to get going, then right here’s somewhat sneak peek of three endpoints you’ll doubtless discover useful when constructing Optimism dapps (decentralized functions):

• getNativeBalance() – Get the native stability of any pockets: 

const response = await Moralis.EvmApi.stability.getNativeBalance({
  "chain": "0xa",
  "deal with": "0xCBA6a2397b322CF1389f6d1adc05F75F36B20116"
});

• getWalletNFTs() – Question all NFTs owned by an deal with: 

const response = await Moralis.EvmApi.nft.getWalletNFTs({
  "chain": "0xa",
  "deal with": "0xCBA6a2397b322CF1389f6d1adc05F75F36B20116"
});

• getTokenPrice() – Fetch the value of any token: 

const response = await Moralis.EvmApi.token.getTokenPrice({
  "chain": "0xa",
  "deal with": "0x4200000000000000000000000000000000000042"
});

The endpoints above are solely three outstanding examples, and should you’d wish to discover the facility of Moralis additional, please be a part of us on this information on the right way to construct dapps on Optimism! Additionally, if you wish to comply with alongside on this tutorial, don’t overlook to enroll with Moralis. You’ll be able to create an account without cost, and also you’ll acquire prompt entry to our industry-leading Web3 APIs! 

Overview 

In at this time’s article, we’ll kick issues off with an summary of constructing dapps on Optimism. From there, we’ll then bounce straight into our tutorial, the place we’ll present you the right way to construct dapps on Optimism in 5 steps utilizing Moralis industry-leading Optimism APIs: 

• Step 1 – Create a Free Dev Account
• Step 2 – Set Up Your Mission
• Step 3 – Select Your Optimism API Endpoints
• Step 4 – Write a Script Calling the Optimism API
• Step 5 – Run the Code

Lastly, to prime issues off, we’ll additionally checklist among the main platforms on Optimism to provide you some inspiration for what you’ll be able to construct sooner or later.

If this sounds thrilling, be a part of us under as we kick issues off by diving straight into our overview of constructing dapps on Optimism! 

An Overview of Constructing Dapps on Optimism 

Optimism launched in 2021, and it’s a number one EVM-compatible ETH layer-2 blockchain. By using optimistic roll-up expertise, Optimism effectively bundles a whole lot of off-chain operations right into a single Ethereum layer-1 transaction. This strategy considerably enhances Ethereum’s scalability by facilitating faster transactions at a low price, offering a extra environment friendly and cost-effective answer for customers and builders alike! 

So, how do you construct decentralized functions (dapps) on Optimism?

Anybody who desires to construct prime Optimism dapps wants entry to an Optimism-compatible API. An API – quick for ”software programming interface” – is a algorithm, protocols, and strategies. Moreover, these assist you to seamlessly work together with a blockchain community to combine Web3 performance and on-chain information into your initiatives. With out APIs, you’ll typically have to arrange the underlying infrastructure for querying the assorted blockchain networks your self, which is a tedious and time-consuming job. 

Anybody seeking to carry their dapps to greater than only one community sooner or later must also ensure that to make use of cross-chain suitable APIs. This may make it tremendous straightforward so that you can increase your initiatives throughout the largest chains, permitting you to succeed in a considerably broader consumer base. 

However the place do you discover the very best Optimism API? 

Properly, on the prime of the checklist of premier Web3 API suppliers, you’ll discover Moralis! 

Moralis’ Web3 APIs provide industry-leading response instances and assist you to scale back the typical time to marketplace for all of your blockchain initiatives by a staggering 83%. As well as, our APIs are cross-chain suitable, supporting networks like Ethereum, Polygon, Solana, and, in fact, Optimism.

When you’d wish to study extra about how one can construct dapps on Optimism with Moralis, be a part of us within the subsequent part, as we’ll stroll you thru a complete five-step tutorial! 

Construct Dapps on Optimism in 5 Steps with Moralis’ API

On this part, we’re going to introduce you to Optimism dapp improvement with Moralis. In doing so, we’ll stroll you thru a quick five-step tutorial on the right way to construct dapps on Optimism: 

• Step 1 – Create a Free Dev Account
• Step 2 – Set Up Your Mission
• Step 3 – Select Your API Endpoints
• Step 4 – Write a Script Calling the Optimism API
• Step 5 – Run the Code

So, with out additional delay, let’s kick issues off by making a free Moralis dev account! 

Step 1 – Create a Free Dev Account 

When you don’t have already got an account, the very first thing it’s worthwhile to do is to click on on the ”Begin for Free” button on the prime proper of Moralis’ web site:

Subsequent, enter your full title, add an electronic mail deal with, and arrange a password: 

Alternatively, you too can create an account utilizing your present Google credentials: 

Establishing an account will take you to our onboarding course of, the place we initially encourage you to inform us a bit about your self: 

From there, you’ll then get to decide on a plan that fits your wants as a developer: 

That’s it; you now have a free Moralis dev account and are able to proceed to the second step! 

Step 2 – Set Up Your Optimism Mission

After creating your account, Moralis will robotically arrange an preliminary venture for you: 

The very first thing you would possibly need to do is rename your venture underneath the ”Settings” tab: 

From there, you’ll be able to then begin exploring the assorted tabs within the menu to the left. As an illustration, on the ”House” tab, you’ll discover a checklist of our APIs:

Or, on the ”Playground” tab, you’ll be able to seamlessly attempt a few of our most well-used endpoints: 

Nevertheless, it’s underneath the ”Settings” tab that you simply’ll discover your API key, which you’re going to want to be able to name the endpoints of our varied APIs:

That covers the fast technique of organising your first Moralis venture. Within the subsequent part, we’ll introduce you to our varied APIs that can assist you select the endpoints it’s worthwhile to construct your dapps on Optimism! 

Step 3 – Select Your Optimism API Endpoints 

In Moralis’ suite of Web3 improvement instruments, you’ll discover greater than ten premier APIs, together with the NFT API, Pockets API, Token API, and plenty of others. With these instruments, you’ll be able to simply construct the whole lot from decentralized exchanges (DEXs) and NFT marketplaces to cryptocurrency wallets on Optimism with out breaking a sweat! 

To offer you an summary of what kinds of Optimism dapps you’ll be able to construct with our industry-leading instruments, we’ll discover the next three Optimism APIs and their respective endpoints in additional element: 

• NFT API
• Pockets API
• Token API

When you’d wish to discover all our out there interfaces, please take a look at the official Web3 API web page. Now, let’s kick issues off by diving into the ins and outs of Moralis’ premier NFT API! 

NFT API 

Moralis’ NFT API is the {industry}’s most complete improvement software for NFT information. The NFT API helps over three million NFT collections throughout ten+ EVM-compatible chains, together with Ethereum, Polygon, and Optimism! 

With solely single traces of code, you need to use the NFT API to fetch enriched metadata, real-time transfers, on-chain value information, and rather more for any NFT. Consequently, when working with this API, you’ll be able to effortlessly construct NFT dapps on Optimism. 

To showcase the facility of the NFT API, listed here are three endpoints you’ll doubtless discover useful in your Optimism improvement endeavors: 

• getWalletNFTs() – Get the NFT stability of any pockets: 

const response = await Moralis.EvmApi.nft.getWalletNFTs({
  "chain": "0xa",
  "deal with": "0xCBA6a2397b322CF1389f6d1adc05F75F36B20116"
});

• getNFTMetadata() – Question the metadata of any NFT: 

const response = await Moralis.EvmApi.nft.getNFTMetadata({
  "chain": "0xa",
  "deal with": "0xB8Df6Cc3050cC02F967Db1eE48330bA23276A492",
  "tokenId": "1"
});

• getNFTOwners() – Fetch the NFT house owners for a given contract: 

const response = await Moralis.EvmApi.nft.getNFTOwners({
  "chain": "0xa",
  "deal with": "0xB8Df6Cc3050cC02F967Db1eE48330bA23276A492"
});

To discover this software additional, please take a look at our official NFT API web page! 

Pockets API 

The Pockets API is the last word answer for pockets builders and anybody seeking to combine pockets performance into their Optimism initiatives. This API helps over 500 million addresses throughout the most well-liked chains. This consists of Ethereum, Polygon, BNB Sensible Chain (BSC), Optimism, and others! 

With the Pockets API, you’ll be able to seamlessly get the native stability, NFT stability, token transfers, profile information, and rather more of any pockets deal with. As such, this industry-leading API offers you the whole lot it’s worthwhile to construct pockets dapps on Optimism. 

Listed below are three outstanding endpoints to spotlight the facility of the Pockets API: 

• getNativeBalance() – Fetch the native stability of any pockets: 

const response = await Moralis.EvmApi.stability.getNativeBalance({
  "chain": "0xa",
  "deal with": "0x2a82ae142b2e62cb7d10b55e323acb1cab663a26"
});

• getWalletTokenBalance() – Question the token balances of any pockets: 

const response = await Moralis.EvmApi.token.getWalletTokenBalances({
  "chain": "0xa",
  "deal with": "0x2a82ae142b2e62cb7d10b55e323acb1cab663a26"
});

• getWalletTransactions() – Get the native transaction historical past of any pockets: 

const response = await Moralis.EvmApi.transaction.getWalletTransactions({
  "chain": "0xa",
  "deal with": "0x2a82ae142b2e62cb7d10b55e323acb1cab663a26"
});

To study extra about this software, please take a look at the official Pockets API web page!

Token API 

Moralis’ Token API is the last word software for fungible token information. The Token API helps each single token throughout ten+ EVM blockchains and counting. This consists of the whole lot from stablecoins like USDT to meme cash like TUX! 

With solely a single API name, you need to use the Token API to fetch token costs, transfers, balances, metadata, and extra. Consequently, when working with the Token API, you’ll be able to construct the whole lot from token explorers to DEXs with ease. 

To focus on the facility of this software, listed here are three outstanding endpoints you’ll doubtless discover helpful when constructing Optimism dapps: 

• getTokenMetadata() – Get the metadata for any fungible token: 

const response = await Moralis.EvmApi.token.getTokenMetadata({
  "chain": "0xa",
  "addresses": [
    "0x4200000000000000000000000000000000000042"
  ]
});

• getTokenPrice() – Question the value of any token:

const response = await Moralis.EvmApi.token.getTokenPrice({
  "chain": "0xa",
  "deal with": "0x4200000000000000000000000000000000000042"
});

• getTokenTransfers() – Fetch all token transactions of a given contract: 

const response = await Moralis.EvmApi.token.getTokenTransfers({
  "chain": "0xa",
  "deal with": "0x4200000000000000000000000000000000000042"
});

If you wish to dive deeper into this interface, please go to the Token API web page! 

Step 4 – Write a Script Calling the Optimism API 

On this part, we’ll present you the right way to name the assorted endpoints of Moralis’ Optimism API. To take action, we’ll write a brief script for fetching the native stability of a pockets with the getNativeBalance() endpoint. Nevertheless, that is merely an Optimism API instance, and you may comply with roughly the identical process for any of our endpoints! 

Earlier than persevering with, ensure you have the next prepared: 

From right here, arrange a brand new folder in your IDE and initialize a brand new venture by operating the next command in a brand new terminal: 

npm init

Subsequent, set up the Moralis SDK with the next terminal command:

npm set up moralis @moralisweb3/common-evm-utils

You then have to open your ”bundle.json” file and add ”sort”: ”module” to the checklist: 

Subsequent, create a brand new ”index.js” file and add the next code: 

import Moralis from 'moralis';

attempt {
  await Moralis.begin({
    apiKey: "YOUR_API_KEY"
  });

  const response = await Moralis.EvmApi.stability.getNativeBalance({
    "chain": "0xa",
    "deal with": "0xCBA6a2397b322CF1389f6d1adc05F75F36B20116"
  });

  console.log(response.uncooked);
} catch (e) {
  console.error(e);
}

From right here, you now have to configure the code barely by changing YOUR_API_KEY together with your Moralis API key, together with modifying the chain and deal with parameters to suit your question.

That’s it; you’re now able to run the script! 

Step 5 – Run the Code 

To execute the script, open a brand new terminal and run the command under in your venture’s root folder: 

node index.js

In return, you’ll get a response that appears one thing like this: 

{
  "stability": "57881481011270850225"
}

That’s it! You now know the right way to fetch the whole lot from pockets balances to token costs utilizing Moralis’ Optimism API suite. Consequently, you’re now outfitted with the abilities to fetch on-chain information and may begin to construct your personal dapps on Optimism! 

Mission Inspiration – Checklist of Optimism Dapps 

Now that you understand how to construct dapps on Optimism with Moralis’ API suite, let’s take this part to discover some already present platforms for inspiration. Extra particularly, we’ll have a look at seven outstanding initiatives on Optimism: 

To study extra about initiatives on Optimism and different chains, be happy to take a look at Moralis’ final dapp retailer: Web3 Wiki! 

Abstract: The right way to Construct Dapps on Optimism in 5 Steps – Optimism API Information 

In at this time’s article, we confirmed you the right way to construct dapps on Optimism in 5 steps utilizing Moralis’ premier Web3 API suite: 

• Step 1 – Create a Free Dev Account
• Step 2 – Set Up Your Mission
• Step 3 – Select Your Optimism API Endpoints
• Step 4 – Write a Script Calling the Optimism API
• Step 5 – Run the Code

In case you have adopted alongside this far, you now know the right way to fetch and combine information from the Optimism blockchain into your initiatives! 

When you like this Optimism API tutorial, contemplate testing extra content material right here on the weblog. As an illustration, learn our information on constructing cryptocurrency value trackers! Additionally, if you wish to leverage Moralis’ Optimism-compatible APIs your self, don’t overlook to enroll with Moralis. You’ll be able to create an account without cost, and also you’ll get prompt entry to our industry-leading suite of Web3 improvement instruments!