How to Build Dapps on Linea - Moralis Web3

Are you on the lookout for one of the best and best solution to construct decentralized purposes (dapps) on Linea? You’ve come to the suitable place. On this information, we’ll introduce you to Moralis – the {industry}’s main Web3 information supplier. With Moralis’ top-tier instruments, you may seamlessly combine on-chain information into your Linea dapps with only a few traces of code, making improvement sooner and extra environment friendly!

For a sneak peek, take a look at our Pockets Historical past endpoint in motion:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

fetch(‘https://deep-index.moralis.io/api/v2.2/wallets/0x5856EDF9212bdceC74301ec78AFc573B62D6A283/historical past?chain=linea’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

In return for calling the endpoint above, you’ll get the complete historical past of the desired pockets. Moreover, the API response is enriched with computerized class tags, summaries, deal with labels, and extra for every occasion, providing you with decoded information straight out of the field. Right here’s an instance of what it’d appear like:

{
//…
“end result”: [
{
//…
“native_transfers”: [
{
“from_address”: “0x53d3801bc009867485eb69e6178e1c0deca3fddc”,
“from_address_label”: null,
“to_address”: “0xde1e598b81620773454588b85d6b5d4eec32573e”,
“to_address_label”: null,
“value”: “9223865045570189”,
“value_formatted”: “0.009223865045570188”,
“direction”: “send”,
“internal_transaction”: false,
“token_symbol”: “ETH”,
“token_logo”: “https://cdn.moralis.io/eth/0x.png”
}
],
“abstract”: “Despatched 0.009224 ETH to 0xde…573e”,
“possible_spam”: false,
“class”: “ship”
},
//…
]
}

To be taught extra about Moralis and find out how to seamlessly construct dapps on Linea, be a part of us on this information as we dive deeper into the method!

Prepared to begin constructing your personal dapps on Linea? Join with Moralis right this moment! You possibly can create a free account and acquire instant entry to our premier nodes and Web3 APIs!

Overview

Whether or not you’re constructing a cryptocurrency pockets, an NFT market, or some other dapps on Linea, seamless entry to on-chain information is important. Nonetheless, querying blockchain information has historically been a cumbersome and time-consuming course of. Doing so from scratch calls for a classy underlying infrastructure, in addition to guide information aggregation and decoding. This takes lots of time that may be higher spent on constructing options and bettering the person expertise of your dapps. As such, there needs to be a greater means, proper?

Happily, now you can streamline on-chain information integration in your Linea dapps with Moralis – Web3’s premier infrastructure supplier. Moralis permits you to question information for wallets, NFTs, tokens, and far more with only a few traces of code. When you’d wish to be taught extra about this, be a part of us on this information as we introduce you to the best solution to construct dapps on Linea. Let’s dive straight in!

What’s Linea?

Linea, developed by ConsenSys and launched in 2023, is a totally EVM-equivalent layer-2 (L2) scaling answer for Ethereum. Designed to boost flexibility and scalability for dapps, Linea gives a extremely enticing atmosphere for each builders and finish customers!

The Linea blockchain, powered by progressive zero-knowledge (ZK) roll-up know-how, gives increased throughput and decrease transaction charges in comparison with Ethereum. That is achieved by bundling a number of off-chain transactions into single ZK-proofs, that are submitted and verified on the Ethereum blockchain in bulk. In consequence, Linea gives lightning-fast transactions whereas sustaining the excessive safety of the Ethereum mainnet.

Regardless of being a comparatively new ecosystem, Linea boasts a considerable community with over a million month-to-month lively customers and greater than 300 dapps. Among the many distinguished names on the community are Stargate, SyncSwap, and Particle Community.

Now that you’ve an outline of Linea, let’s discover among the advantages of constructing dapps on this progressive chain!

Why Construct Dapps on Linea?

Constructing dapps on Linea generally is a nice choice. To focus on why, we’ll now discover 5 advantages of the community:

EVM Equivalence: Linea is absolutely EVM equal, making certain seamless compatibility with present Ethereum good contracts and dapps. This makes it easy for builders emigrate their initiatives to Linea with out important modifications to their codebases. Ease of Use: With its EVM equivalence, Linea helps many acquainted instruments, together with wallets like MetaMask, languages like Solidity, and frameworks like Truffle. This familiarity considerably simplifies the event course of. Value Effectivity: By decreasing fuel charges and growing throughput, Linea is ready to provide a cheap answer for each builders and finish customers. This effectivity is especially advantageous for micro-transactions and dapps with a big person base. Scalability: Linea is designed to deal with extra transactions per second than Ethereum, enhancing the community’s scalability. This makes Linea a really perfect platform for dapps requiring excessive throughputs, comparable to DeFi platforms and Web3 video games. Safety: As an L2 scaling answer, Linea advantages from the safety of the Ethereum mainnet, making certain that each one transactions are processed safely.

Blockchain nodes with text: "Benefits of Building Dapps on Linea."

Introducing Moralis – The Best Technique to Construct Dapps on Linea

The best solution to construct dapps on Linea is to leverage a Web3 information supplier like Moralis. In our suite of industry-leading improvement instruments, you’ll discover nodes for all main blockchain networks and 10+ use case-specific APIs. This contains our premier NFT API, Pockets API, Token API, Worth API, and lots of others. As such, whether or not you’re trying to construct an NFT market, cryptocurrency pockets, or some other dapps for the Linea community, we’ve obtained you coated!

However why must you use Moralis to construct dapps on Linea?

Complete: Moralis gives the {industry}’s most detailed API responses, permitting you to entry in depth information with fewer calls. Fetch info from each on- and off-chain sources with a single API request, making your dapp improvement extra environment friendly. Easy: With full cross-chain compatibility, Moralis gives full characteristic parity throughout all main blockchains, together with Linea, Ethereum, and Polygon. This unified toolkit streamlines your developer expertise, which means you don’t should hassle with a brand new supplier for every chain you work together with. Safe: Moralis units the gold customary for enterprise-grade information safety. We’re proud to be the one SOC 2 Kind 2 licensed Web3 infrastructure supplier within the {industry}, making certain the very best stage of safety in your initiatives.

Moralis Web3 APIs – Finest Instruments to Construct Dapps on Linea

The best solution to construct dapps on Linea is to leverage our premier Web3 APIs, permitting you to seamlessly streamline on-chain information integration in your initiatives with a number of traces of code. Because of the in depth variety of specialised interfaces provided by Moralis, we received’t be capable of cowl all of them on this information. As such, we’ll as a substitute introduce you to 3 distinguished examples:

Pockets APIToken APINFT API

When you’d wish to discover all our Linea-compatible interfaces, please take a look at our Web3 API web page, the place you’ll discover the remaining!

Pockets API

Moralis’ Pockets API is the {industry}’s main software for accessing pockets information. With this premier interface, you may seamlessly fetch any pockets’s historical past, token balances, web price, profitability, and far more with only a single API name. So, whether or not you’re constructing crypto wallets, portfolio trackers, or different dapps on Linea, the Pockets API makes it simple!

To exhibit the facility of the Pockets API, right here’s an instance of how one can fetch a pockets’s complete historical past with one endpoint:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

By calling the endpoint above, you’ll obtain the complete historical past of the pockets. Moreover, the response is enriched with computerized class tags, summaries, and extra, offering absolutely decoded information proper out of the field. Right here’s an instance of what the response would possibly appear like:

Discover our official Pockets API documentation to find different endpoints you should use to construct dapps on Linea!

Token API

The Token API is the main software in Web3 for fetching ERC-20 information. With this top-tier interface, you may simply get token balances, metadata, house owners, costs, and extra utilizing only a single line of code. Consequently, this highly effective software lets you effortlessly create a variety of dapps, from token explorers like Moralis Cash to decentralized exchanges (DEXs) like Uniswap.

To exhibit the accessibility of our Token API, let’s take a fast have a look at our endpoint for fetching balances with costs:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

fetch(‘https://deep-index.moralis.io/api/v2.2/wallets/0x5856EDF9212bdceC74301ec78AFc573B62D6A283/tokens?chain=linea’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

By calling the script above, you’ll obtain an array of all tokens held by the desired pockets. Moreover, the response is enriched with costs, worth modifications over time, and extra particulars for every token. Right here’s an instance of what the response would possibly appear like:

{
//…
“end result”: [
{
“token_address”: “0xa219439258ca9da29e9cc4ce5596924745e12b93”,
“symbol”: “USDT”,
“name”: “Tether USD”,
“logo”: null,
“thumbnail”: null,
“decimals”: 6,
“balance”: “542905179549”,
“possible_spam”: false,
“verified_contract”: false,
“total_supply”: “15290859809510”,
“total_supply_formatted”: “15290859.80951”,
“percentage_relative_to_total_supply”: 3.5505209406952085,
“balance_formatted”: “542905.179549”,
“usd_price”: 0.9998899192502502,
“usd_price_24hr_percent_change”: -0.011008074974938614,
“usd_price_24hr_usd_change”: -0.00011008074974938609,
“usd_value”: 542845.4161397922,
“usd_value_24hr_usd_change”: -59.76340920757502,
“native_token”: false,
“portfolio_percentage”: 58.9964
},
//…
]
}

Discover our Token API documentation to be taught extra about our different endpoints!

NFT API

Moralis’ NFT API is one of the best software for accessing NFT information. This premier interface permits you to acquire NFT balances, metadata, costs, and far more with single endpoints. This makes it the proper API for constructing NFT marketplaces, Web3 video games, and different dapps that depend on NFT information!

To focus on the advantages of the NFT API, let’s check out our endpoint for fetching balances:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

fetch(‘https://deep-index.moralis.io/api/v2.2/0x1F5876Da8Ed41b8DB49b9A82EA690fd8011394d1/nft?chain=linea’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

Calling the endpoint above will give you an array of NFTs held by the desired pockets. Right here’s an instance of what the response would possibly appear like:

{
//…
“end result”: [
{
“amount”: “1”,
“token_id”: “4”,
“token_address”: “0x0872ec4426103482a50f26ffc32acefcec61b3c9”,
“contract_type”: “ERC1155”,
“owner_of”: “0x1f5876da8ed41b8db49b9a82ea690fd8011394d1”,
“last_metadata_sync”: “2024-05-23T08:08:31.529Z”,
“last_token_uri_sync”: “2024-05-23T08:08:31.454Z”,
“metadata”: “{“name”:”Linea Voyage – Delta Edition”,”description”:”The Delta Edition represents the inception of the network, the moment of instantiation of the testnet and activation of the community effort, sending waves of energy throughout the network, and setting into motion the potential to come.”,”image”:”ipfs://Qmb31479z12SzfoskmhN2KRHRtZ3fnmm3TKeET4VtXs1Q9″,”animation_url”:”ipfs://Qmdu7CwEP5dSm5Y7iyV8AhPdJygpKkKeyqA1SyVezVkdHD”,”attributes”:[{“trait_type”:”Tier”,”value”:”4″}]}”,
“block_number”: “3912275”,
“block_number_minted”: null,
“identify”: “Linea Voyage”,
“image”: “VOYAGE”,
“token_hash”: “9fb8de84306e2d372edcf8f25f058d00”,
“token_uri”: “https://ipfs.moralis.io:2053/ipfs/QmfFuKPuUPyPMytHvhfBHcspqBSw4sQsXsbmhAFDVrTJUL”,
“minter_address”: “ERC1155 tokens haven’t got a single minter”,
“verified_collection”: false,
“possible_spam”: false,
“collection_logo”: null,
“collection_banner_image”: null
},
//…
]
}

To be taught extra about our different endpoints, please go to the official NFT API documentation web page!

3-Step Tutorial: How one can Construct Dapps on Linea with Moralis

Now that you’ve explored one of the best instruments for constructing dapps on Linea, we’ll information you thru a tutorial on find out how to use them. Particularly, we’ll present you find out how to get the native steadiness of any deal with in three easy steps utilizing our Pockets API:

Step 1: Receive Your Moralis API KeyStep 2: Write a Script to Name Our Native Steadiness EndpointStep 3: Run the Code

Nonetheless, earlier than continuing, let’s cowl some obligatory stipulations!

Stipulations

To comply with together with the steps beneath, guarantee you may have the next stipulations prepared:

Step 1: Receive Your Moralis API Key

When you haven’t already, register for a free account with Moralis by clicking the “Begin for Free” button on the high proper:

Arrow pointing at "Start for Free" button.

As soon as logged in, navigate to the “Residence” tab to seek out your API key:

Arrow is pointing at the copying button for the API key Moralis admin panel.

Copy and save the important thing for now, as you’ll want it within the second step!

Step 2: Write a Script Calling the Native Balances Endpoint

Open your most well-liked IDE, arrange a folder, and initialize a mission utilizing the next terminal command:

npm init

Set up the required dependencies by working the terminal command beneath:

npm set up node-fetch –save
npm set up moralis @moralisweb3/common-evm-utils

Add “kind”: “module” to the ”bundle.json” file:

"type": "module" added to package.json file for Linea dapps.

Create a brand new ”index.js” file and add the next code:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOU_API_KEY’
},
};

fetch(‘https://deep-index.moralis.io/api/v2.2/0x2898730f10411D6E92cad809e78cc3a7Ea82C695/steadiness?chain=eth’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

Change YOUR_API_KEY along with your Moralis API key and configure the deal with parameter to suit your question:

That’s it for the code! All that continues to be now could be to run the script!

Step 3: Run the Code

Open a brand new terminal, navigate to your mission’s root folder, and run the enter beneath to execute the script:

node index.js

In return, you’ll get the native steadiness of the desired pockets. Right here’s an instance of what it’d appear like:

{ steadiness: ‘904846316993485’ }

That’s it! Getting on-chain information doesn’t should be more difficult than this when utilizing Moralis. From right here, you may comply with the identical steps to name any of our different endpoints. With these instruments, you now have all the pieces it’s essential to construct wonderful dapps on Linea!

Abstract: How one can Construct Dapps on Linea

When constructing dapps on Linea, you want a seamless solution to combine on-chain information into your mission. Nonetheless, doing so from scratch is a bothersome and time-consuming course of. It requires establishing an underlying infrastructure and manually aggregating and decoding the info. Happily, now you can streamline the method with a Web3 information supplier like Moralis!

Moralis gives the instruments it’s essential to seamlessly combine on-chain information into your dapps. Our complete toolkit contains nodes for over 20 networks and greater than ten use case-specific APIs, such because the Token API, Pockets API, and Streams API.

Right here’s why it’s best to construct dapps on Linea with Moralis:

Complete: Our outcome-driven APIs present extra information with fewer API calls in comparison with the competitors, making your dapp improvement on Linea extra environment friendly. Cross-Chain: Our API suite is absolutely cross-chain suitable, eliminating the necessity for a brand new supplier for every blockchain you work together with. The supported networks embody Linea, Ethereum, Polygon, BSC, Optimism, Arbitrum, Avalanche, and lots of extra. Safe: Moralis is the one SOC 2 Kind 2 licensed Web3 infrastructure supplier, making certain enterprise-grade information safety.

So, in case you’d like to begin constructing dapps on Linea your self, bear in mind to enroll with Moralis. You possibly can create an account free of charge, and also you’ll acquire instantaneous entry to our top-tier APIs and nodes!

Moreover, in case you’re critical about constructing dapps on Linea, make sure to take a look at different instruments provided by Moralis. As an illustration, to get free testnet tokens you should use throughout your improvement endeavors, be certain to take a look at our Linea Goerli faucet article now!

Source link