In at present’s article, we’ll present you the way to construct dapps on Optimism with Moralis’ industry-leading Web3 API suite. With our premier improvement instruments, you may seamlessly fetch and combine on-chain knowledge into your Optimism initiatives with solely single traces of code. For those who’re wanting to get going, then right here’s slightly sneak peek of three endpoints you’ll seemingly discover useful when constructing Optimism dapps (decentralized purposes):
getNativeBalance()
– Get the native stability of any pockets:
const response = await Moralis.EvmApi.stability.getNativeBalance({ "chain": "0xa", "tackle": "0xCBA6a2397b322CF1389f6d1adc05F75F36B20116" });
getWalletNFTs()
– Question all NFTs owned by an tackle:
const response = await Moralis.EvmApi.nft.getWalletNFTs({ "chain": "0xa", "tackle": "0xCBA6a2397b322CF1389f6d1adc05F75F36B20116" });
getTokenPrice()
– Fetch the value of any token:
const response = await Moralis.EvmApi.token.getTokenPrice({ "chain": "0xa", "tackle": "0x4200000000000000000000000000000000000042" });
The endpoints above are solely three distinguished examples, and for those who’d wish to discover the ability of Moralis additional, please be part of us on this information on the way to construct dapps on Optimism! Additionally, if you wish to comply with alongside on this tutorial, don’t neglect to enroll with Moralis. You possibly can create an account without spending a dime, and also you’ll achieve instantaneous entry to our industry-leading Web3 APIs!
Overview
In at present’s article, we’ll kick issues off with an outline of constructing dapps on Optimism. From there, we’ll then leap straight into our tutorial, the place we’ll present you the 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 Venture
- Step 3 – Select Your Optimism API Endpoints
- Step 4 – Write a Script Calling the Optimism API
- Step 5 – Run the Code
Lastly, to high issues off, we’ll additionally record among the main platforms on Optimism to present you some inspiration for what you may construct sooner or later.
If this sounds thrilling, be part of us beneath 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 know-how, Optimism effectively bundles lots of 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 value, offering a extra environment friendly and cost-effective resolution for customers and builders alike!
So, how do you construct decentralized purposes (dapps) on Optimism?
Anybody who desires to construct high Optimism dapps wants entry to an Optimism-compatible API. An API – quick for ”software programming interface” – is a algorithm, protocols, and strategies. Moreover, these help you seamlessly work together with a blockchain community to combine Web3 performance and on-chain knowledge into your initiatives. With out APIs, you’d usually must arrange the underlying infrastructure for querying the assorted blockchain networks your self, which is a tedious and time-consuming job.
Anybody seeking to convey their dapps to greater than only one community sooner or later must also make certain to make use of cross-chain suitable APIs. This can make it tremendous simple so that you can develop your initiatives throughout the most important chains, permitting you to succeed in a considerably broader consumer base.
However the place do you discover one of the best Optimism API?
Properly, on the high of the record of premier Web3 API suppliers, you’ll discover Moralis!
Moralis’ Web3 APIs supply industry-leading response occasions and help you cut 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.
For those who’d wish to be taught extra about how one can construct dapps on Optimism with Moralis, be 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 way to construct dapps on Optimism:
- Step 1 – Create a Free Dev Account
- Step 2 – Set Up Your Venture
- 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
For those who don’t have already got an account, the very first thing it’s essential to do is to click on on the ”Begin for Free” button on the high proper of Moralis’ web site:
Subsequent, enter your full title, add an e-mail tackle, and arrange a password:
Alternatively, you can even create an account utilizing your present Google credentials:
Organising 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 Venture
After creating your account, Moralis will routinely arrange an preliminary challenge for you:
The very first thing you may need to do is rename your challenge beneath the ”Settings” tab:
From there, you may then begin exploring the assorted tabs within the menu to the left. As an example, on the ”House” tab, you’ll discover a record of our APIs:
Or, on the ”Playground” tab, you may seamlessly attempt a few of our most well-used endpoints:
Nevertheless, it’s beneath the ”Settings” tab that you simply’ll discover your API key, which you’re going to wish to be able to name the endpoints of our numerous APIs:
That covers the short technique of establishing your first Moralis challenge. Within the subsequent part, we’ll introduce you to our numerous APIs that can assist you select the endpoints it’s essential 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 may simply construct all the pieces from decentralized exchanges (DEXs) and NFT marketplaces to cryptocurrency wallets on Optimism with out breaking a sweat!
To present you an outline of what sorts of Optimism dapps you may 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
For those who’d wish to discover all our obtainable interfaces, please try 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 instrument for NFT knowledge. 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 should utilize the NFT API to fetch enriched metadata, real-time transfers, on-chain worth knowledge, and way more for any NFT. Consequently, when working with this API, you may effortlessly construct NFT dapps on Optimism.
To showcase the ability of the NFT API, listed here are three endpoints you’ll seemingly discover useful in your Optimism improvement endeavors:
getWalletNFTs()
– Get the NFT stability of any pockets:
const response = await Moralis.EvmApi.nft.getWalletNFTs({ "chain": "0xa", "tackle": "0xCBA6a2397b322CF1389f6d1adc05F75F36B20116" });
getNFTMetadata()
– Question the metadata of any NFT:
const response = await Moralis.EvmApi.nft.getNFTMetadata({ "chain": "0xa", "tackle": "0xB8Df6Cc3050cC02F967Db1eE48330bA23276A492", "tokenId": "1" });
getNFTOwners(
) – Fetch the NFT house owners for a given contract:
const response = await Moralis.EvmApi.nft.getNFTOwners({ "chain": "0xa", "tackle": "0xB8Df6Cc3050cC02F967Db1eE48330bA23276A492" });
To discover this instrument additional, please try our official NFT API web page!
Pockets API
The Pockets API is the last word resolution for pockets builders and anybody seeking to combine pockets performance into their Optimism initiatives. This API helps over 500 million addresses throughout the preferred chains. This consists of Ethereum, Polygon, BNB Sensible Chain (BSC), Optimism, and others!
With the Pockets API, you may seamlessly get the native stability, NFT stability, token transfers, profile knowledge, and way more of any pockets tackle. As such, this industry-leading API offers you all the pieces it’s essential to construct pockets dapps on Optimism.
Listed below are three distinguished endpoints to spotlight the ability of the Pockets API:
getNativeBalance()
– Fetch the native stability of any pockets:
const response = await Moralis.EvmApi.stability.getNativeBalance({ "chain": "0xa", "tackle": "0x2a82ae142b2e62cb7d10b55e323acb1cab663a26" });
getWalletTokenBalance()
– Question the token balances of any pockets:
const response = await Moralis.EvmApi.token.getWalletTokenBalances({ "chain": "0xa", "tackle": "0x2a82ae142b2e62cb7d10b55e323acb1cab663a26" });
getWalletTransactions()
– Get the native transaction historical past of any pockets:
const response = await Moralis.EvmApi.transaction.getWalletTransactions({ "chain": "0xa", "tackle": "0x2a82ae142b2e62cb7d10b55e323acb1cab663a26" });
To be taught extra about this instrument, please try the official Pockets API web page!
Token API
Moralis’ Token API is the last word instrument for fungible token knowledge. The Token API helps each single token throughout ten+ EVM blockchains and counting. This consists of all the pieces from stablecoins like USDT to meme cash like TUX!
With solely a single API name, you should utilize the Token API to fetch token costs, transfers, balances, metadata, and extra. Consequently, when working with the Token API, you may construct all the pieces from token explorers to DEXs with ease.
To focus on the ability of this instrument, listed here are three distinguished endpoints you’ll seemingly 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", "tackle": "0x4200000000000000000000000000000000000042" });
getTokenTransfers()
– Fetch all token transactions of a given contract:
const response = await Moralis.EvmApi.token.getTokenTransfers({ "chain": "0xa", "tackle": "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 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’ll comply with roughly the identical process for any of our endpoints!
Earlier than persevering with, be sure to have the next prepared:
From right here, arrange a brand new folder in your IDE and initialize a brand new challenge by working 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 must open your ”bundle.json” file and add ”sort”: ”module”
to the record:
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", "tackle": "0xCBA6a2397b322CF1389f6d1adc05F75F36B20116" }); console.log(response.uncooked); } catch (e) { console.error(e); }
From right here, you now must configure the code barely by changing YOUR_API_KEY
along with your Moralis API key, together with modifying the chain
and tackle
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 beneath in your challenge’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 way to fetch all the pieces from pockets balances to token costs utilizing Moralis’ Optimism API suite. Consequently, you’re now outfitted with the abilities to fetch on-chain knowledge and may begin to construct your individual dapps on Optimism!
Venture Inspiration – Checklist of Optimism Dapps
Now that you know the way to construct dapps on Optimism with Moralis’ API suite, let’s take this part to discover some already current platforms for inspiration. Extra particularly, we’ll take a look at seven distinguished initiatives on Optimism:
Checklist of Optimism Dapps | |||
Identify | Description | ||
1. Uniswap | Uniswap is an automatic market maker (AMM) DEX for swapping cryptocurrency tokens. | ||
2. Stargate | Stargate is a liquidity transport protocol permitting customers to bridge property from different blockchains to Optimism securely. | ||
3. Aave | Aave is a decentralized crypto platform that permits customers to lend and borrow cryptocurrency. | ||
4. Curve | Curve is an AMM-based DEX specializing in stablecoins like USDT, DAI, USDC, and extra. | ||
5. Perpetual Protocol | Perpetual Protocol is a decentralized perpetual futures alternate. | ||
6. Belief Pockets | Belief Pockets is a number one self-custody cryptocurrency pockets that’s suitable with Optimism. | ||
7. MetaMask | MetaMask is among the {industry}’s greatest self-custodial cryptocurrency wallets. |
To be taught extra about initiatives on Optimism and different chains, be happy to take a look at Moralis’ final dapp retailer: Web3 Wiki!
Abstract: How you can Construct Dapps on Optimism in 5 Steps – Optimism API Information
In at present’s article, we confirmed you the 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 Venture
- Step 3 – Select Your Optimism API Endpoints
- Step 4 – Write a Script Calling the Optimism API
- Step 5 – Run the Code
If in case you have adopted alongside this far, you now know the way to fetch and combine knowledge from the Optimism blockchain into your initiatives!
For those who like this Optimism API tutorial, contemplate trying out extra content material right here on the weblog. As an example, learn our information on constructing cryptocurrency worth trackers! Additionally, if you wish to leverage Moralis’ Optimism-compatible APIs your self, don’t neglect to enroll with Moralis. You possibly can create an account without spending a dime, and also you’ll get instantaneous entry to our industry-leading suite of Web3 improvement instruments!