GMT Token

gmttoken

Coinbase is the largest cryptocurrency exchange in the USA. It’s called the industry’s unicorn and a leader in mergers and acquisitions with the biggest influence across the USA market. The platform is second only to Binance in terms of trading volume while adhering to the rather old-fashioned policy in the listing procedure, which is why Coinbase supports fewer assets than Binance. Over the years, there has been a trend noticed around Coinbase - when a coin is listed on the exchange and announced on media, this sharply moves its rate upward. But, does it always work so with Coinbase, or is this only a short-term trend? Let’s try to figure it out today. Incredible Growth But Only Temporary Let’s consider the example of OmiseGO (OMG) that was listed on Coinbase. We can see, OMG rate multiplied on the first day of listing on Coinbase, followed by a sharp drop right after it soared. The number of OmiseGO addresses increased by 99,6% a day before the listing, compared with the number of addresses fixed the day before. The total number of active addresses was the biggest since November 2018. On May 21, the number of on-chain transactions increased by 83,9% compared with the previous day, reaching the highest level ever. The same thing about Chainlink - the rate grew from $2,60 to $5,10 before the listing and dropped to $3,80 afterward. Similarly, with OmiseGO, the number of active addresses registered and transactions in Chainlink reached its maximum level on a listing day. Another example is MKR listing (the token of the DeFi project MakerDAO), we can see its rate skyrocketed 40% right after its listing was announced on Coinbase. It was followed by short correction of the price. The token’s rate went up just before the listing, reaching its all-time high of $730. However, the MKR price showed a downward trend right after the start of the trades. This phenomenon can be explained by too many rumors and hype around the coin before its listing, for all the cases we consider in this article are followed by sharp price growth right before the trades start, and the closer to listing - the bigger the price growth rate we observe. And in the end, harsh correction in all the cases. This phenomenon got the name “the Coinbase effect,” and it was noticed that it takes place simultaneously with increasing on-chain activity. Probably the loudest skyrocketing rate was noticed when Bitcoin Cash (BCH) was listed on Coinbase. It was in late 2017 - that was the peak of the crypto market when Bitcoin was about to reach $20 000 with a market cap of $800 billion. Once Coinbase announced support for the main Bitcoin fork, its rate soared to almost $4000, but the trades were ceased in a couple of minutes, for volatility was too high, and the growth was recognized as suspicious. Similar to the cases we mentioned before, the sharp upward rate movement followed after the Coinbase announcement. As a matter of fact, the BCH rate skyrocketed even higher up to $9500 from about $2400-2500 level on the former GDAX  exchange (now Coinbase Pro). The same drop followed once the trades ceased. A similar situation happened with XRP, Dash, Zcash listing, as well as many others, following with sharp price soaring and the same sharp drop afterward. Looking at such sharp volatility fluctuations on the listing eve and right after the trades are opened, the company’s CEO supposed insider trading might occur and promised to figure it out. The company even received a class action blaming Coinbase for insider trading during the BCH listing. No proof was found, though. One of the latest situations of unnaturally sharp volatility was fixed with the DeFi token Compound listing when the COMP rate fell right after the trades were opened. The asset trades opened at $400 and dropped twice. The reason may be that some early investors wanted to make money on the hype around COMP, for its rate was moving steadily up before the listing on Coinbase. When the trades were opened, there were 25 transactions fixed each for 2000 COMP to the exchange wallets. Listing on Binance This is the largest exchange in terms of trading volume, with strict conditions for listing which are not clearly defined in any source. The head of the trading platform says that they reject 97-98% of applications. Requirements for applications: -fill out the form on binance.com, providing the information about your project; -send the application and wait for the answer. The stage of the application consideration can be known on binance.com only, so it does not make sense to write to tech support or reach Binance management on their social networks. Criteria when considering an application: -applicants trying to put pressure on the Binance managers are dropped out; -promises to pay million dollars for listing will not work either - the company values reputation first and foremost; -the exchange is favorably disposed to projects and companies that used to help promote BNB - the native token of Binance. -when evaluating a project, the Binance team carefully analyzes its usefulness, applicability for solving actual problems, the audience interested in it, listing on other exchanges, and trading volume; -it does not matter how much you are willing to pay for the listing - it will not work. The developers of “shit coins'  would pay any amount of money for listing on such a large player as Binance, but they are out, so money - in any amount - is not a ticket to Binance listing. The exchange definitely charges some fee for listing, but there is no certain information about it, nor does the Binance head comment on this issue. GMT Token’s case GMT Token company is working to make it to Binance - the largest crypto platform that affects assets' rates equally or even more than Coinbase. According to our sources, in 2022, GMT will start to implement the next stage of its strategy. Besides using their mining capacities, the team will attract other participants in the mining market to place their equipment in the project’s ecosystem. New miners will be offered to place their equipment in GMT data centers. In return, miners will receive GMT tokens in an amount proportional to the power security. Part of the tokens will be burned, and the released power will be distributed among all tokens in circulation. If this strategy is implemented successfully, the token power security will sharply increase, and its value may reach $1.5 in the next 12 months. It is clear from the foregoing why the company did not rush to receive a listing on Binance and preferred local exchanges instead. Now listing on Binance looks quite logical in 2022. Other Factors However, the Coinbase effect seems to be overestimated, for, as a matter of fact, the announcements of new tokens to be listed on the exchange usually cause their price fluctuations within -1% - +14% related to USD, BTC, ETH. Experts estimated that the exchange announcements have no significant influence on general market trends of the assets announced. They studied 16 assets added to the exchange, and 6 of them showed a downward trend within 10 days after the listing, while only 3 raised less than 5%. So on average, the fluctuation was estimated at +4%. As for Coinbase announcements and their effect on the asset rates, here experts see the bigger reason is a general market trend happening along with short-term effects from the exchange announcements. For example, in 2018, most of the assets went down during the bearish market trend. In 2019 the rates moved up and down. So it appears that the dynamic largely depends on the market trend at the time when the asset was listed, while Coinbase news mostly bears a short-term effect on the assets rates. Most crypto assets did not maintain high prices and dropped in a few days after listing, which refers to the assets with low liquidity (LOOM, CVC). Some kept their prices at the same high level (GNT), while others skyrocketed (OMG, XTZ). The Block research shows the following dynamics on the day when Coinbase announced listing: The assets grew by 9% towards USD and 8%  to BTC on average. 14 out of 16 assets showed a positive trend. Then the rates dropped during 24 hours from the trades opening, 1%  towards USD per day on average. 5 out of 19 assets showed a positive trend. Within a week after listing, most of the assets kept on downward movement -3% towards USD and -1% to BTC on average. 2 out of 19 assets showed a positive trend during the week, especially Chainlink we have mentioned before. In a month after the listing, the drop was estimated at -6% on average: 5 out of 19 assets grew towards USD and BTC, especially Zilliqa, which did not show an upward trend the first day after the listing. Wrapping Up We can’t put it all on the Coinbase effect and blame it for those impulse assets fluctuations after the listing, for there may be several reasons, and the biggest might be a general market trend. The upward trend of new-added coins on the exchange is usually of short-tern nature, and it does not last long if the market is bearish. Besides, we should also keep in mind the level of assets’ liquidity, which also plays an essential role in future rate changes. Trying to grab coins and wait for the rate boost, trying to make a big deal of fortune, we should bear in mind that such trading activities are pretty risky, and we should be especially careful and remember that there are plenty of factors influencing the prices and behavior of the asset. So, to some extent, those huge rate fluctuations might be caused by the Coinbase effect, but it would be naive to think it's all about the exchange announcements. It is recommended to make a big deal of research across the cryptocurrency and the factors that might be crucial in its rate changes before investing in this or that digital asset.

What is the Coinbase Effect and is it Worth Relying On

Crypto mining has garnered a lot of popularity in recent months, and it is for both right and wrong reasons. The growing crypto buzz has so much shifted the attention of most people to the end-product, and every few people care to know how these digital assets come about. Today, different governments are clamping down on mining due to its environmental impact. The is currently cracking down on crypto miners, and the resultant effect has reverberated across the crypto space. Although other countries like Thailand are also cracking down on crypto mining, China stood out because Chinese government more than 60% of miners are based in China. On the other hand, the government of is working on utilizing volcanic energy to mine bitcoin. This will be a total shift from the use of non-renewable sources of energy that is harmful to the environment. For those of you who might be wondering what crypto mining is, adding transaction records to the blockchain protocol is the process of adding transaction records. In order to add the record to the blockchain, the miner must have to solve a computational puzzle. El Salvador Mining is essential in the crypto space for many reasons do not just add any transaction record to the blockchain network; these transactions are vetted and verified to be correct. Therefore, without the mining process, there will be no way to ensure the integrity of the blockchain protocol. With their power-intensive computers, these miners can listen to transaction requests across the entire blockchain network and sort out the valid ones. Crypto miners Just like bank tellers, these miners check to ensure all things are in place before validating a transaction. Miners lookout for two things while validating a transaction. First, they check to make sure that the digital signature of the recipient of an input proves that they are the right person to get the input. Secondly, miners also help to make sure that the recipient is yet to use that input. Crypto mining helps prevent a problem known as “double spending,” a form of high-tech counterfeiting. Imagine a user say Dave has $10 and gives it to Jane. Can Jane be certain that she has received $10 from Dave and is not fake? It would have been easy in real life, but it is not that simple in the digital world. Upon validation, if transactions fail to check due to counterfeiting, miners will not record that transaction, and the fraud will be averted. Although crypto mining has lots of benefits, two major problems have cast a big shadow on mining The computational puzzle that miners need to solve before adding a block to the already existing blockchain requires enormous hardware. This hardware is known as Application-Specific Integrated Circuit (ASICs), and they consume a lot of energy. According to the , bitcoin has the same energy consumption rate as Argentina. This means miners spend a lot of money on energy to power their equipment. Cambridge Bitcoin Electricity Consumption Index The doesn’t come cheap, and you will need hundreds of them to execute a mining process. With this expensive AISC equipment, not everyone can get into the business of mining cryptocurrency. However GoMining is already the problem of the high cost of equipment -  the company has created a token (GMT) that allows holders to earn income from mining without having to own any ASIC equipment. Therefore, instead of owning the expensive and energy-intensive ASICs to mine bitcoin, holders of the GMT token can share the mining income generated by the company's fleet of devices. Application-Specific Integrated Circuits solving There are other companies also seeking to offer a better solution to the problems of mining. Gryphon Digital Mining platform is planning on creating the largest bitcoin miner with little or no carbon footprint. Another company that is working to solve the high energy consumption rate of mining is Mercuria. According to the CEO, , the company is seeking to partner with crypto miners and supply them with renewable energy for their mining processes. This will help reduce the emission of carbon (IV) oxide emission associated with non-renewable energies. Marco Dunand Conclusion The concept of mining is integral and essential to the future of cryptocurrency and blockchain networks. Government should be more diplomatic in its clampdown on crypto mining. Instead of shutting down a mining site, there should be a roadmap that miners should follow in order to achieve a robust and environmentally friendly. Also, more crypto projects need to rise to the occasion in tackling the problems of mining.

The Rising Popularity of Crypto Mining

Explanation of ERC-6900: Modular Smart Contract Accounts and Plugins

Hey there! I have been for a long time in dApps developement and I know on my own how it is difficult to get started with blockchain APIs. Especially with their endpoints. I decided to gather the most important endpoints for Ethereum, Binance, Bitcoin, Ploygon, and Solana blockchains in this article. I tried to be consistent and to the point. Hope they will help you! Ethereum API The Ethereum API is fundamental for developers working on the Ethereum network. It provides access to blockchain data, enabling interaction with smart contracts and account management. Key endpoints include: eth_call. Executes a message call immediately without creating a transaction.
eth_getTransactionByHash. Retrieves transaction details using its hash.
eth_getBlockByNumber. Returns block information by its number.
eth_getCode. Retrieves the code at a specific address, useful for checking smart contracts' bytecode.
eth_getLogs. Fetches logs from smart contracts, often used to track events like token transfers.
eth_estimateGas. Estimates the gas required to execute a transaction, helping developers calculate costs.
eth_gasPrice. Returns the current gas price in the network, essential for setting transaction fees.
eth_getTransactionCount. Retrieves the number of transactions sent from an address, often used to get the nonce for new transactions. These endpoints are imperative for building dApps that require real-time blockchain data. I mean DeFi platforms and NFT marketplaces. For example, eth_call is used to query token balances in smart contracts without broadcasting a transaction. Solana API Solana's API is designed for high-speed, scalable applications. This is why Solana is a popular choice for developers focused on performance. Key endpoints include: getRecentBlockhash. Fetches the latest block hash needed for signing transactions.
getAccountInfo. Retrieves account data like balance and ownership.
sendTransaction. Submits a transaction to the network.
getConfirmedBlock. Retrieves information about a specific confirmed block, including all transactions.
getConfirmedSignaturesForAddress2. Fetches signatures for confirmed transactions associated with an address.
getSupply. Provides the total supply of SOL, the native token of Solana.
getProgramAccounts. Returns all accounts owned by a particular program (smart contract).
getTokenAccountsByOwner. Retrieves token accounts owned by a specific public key, useful for querying balances of various tokens. These endpoints support Solana’s proof-of-history (PoH) system, which timestamps transactions to ensure fast processing. For instance, sendTransaction is imperative for executing trades on DEXs built on Solana. There, low latency is crucial. Bitcoin API Bitcoin's API provides essential tools for interacting with the Bitcoin blockchain. They focuse on transaction and wallet management. Key endpoints include: getblockchaininfo. Retrieves the current blockchain state, including block count and difficulty.
getrawtransaction. Retrieves detailed transaction information using its ID.
getbalance. Returns the balance of a specified wallet address.
listunspent. Lists unspent transaction outputs (UTXOs) for a set of addresses, essential for constructing new transactions.
sendrawtransaction. Submits a raw transaction (created and signed offline) to the Bitcoin network.
getmempoolinfo. Provides information about the nodes' memory pool (mempool), where unconfirmed transactions are held.
getblockhash. Retrieves the block hash of a block based on its height, useful for navigating the blockchain.
decoderawtransaction. Decodes a raw transaction hex string into a readable JSON object, helping to understand transaction details before broadcasting. These endpoints are standard in Bitcoin’s JSON-RPC API and are used in various Bitcoin-related development tasks. The getrawtransaction endpoint, for example, is used to verify transaction details before confirmation in a block. Polygon API Polygon offers a Layer 2 scaling solution for Ethereum, optimized for lower transaction costs and higher throughput. Key endpoints include: eth_blockNumber. Retrieves the most recent block number.
eth_sendTransaction. Sends a transaction to the network with significantly lower gas fees.
eth_getLogs. Fetches event logs from the blockchain, useful for tracking smart contract events.
eth_getBlockByHash. Fetches block information using the block hash, similar to eth_getBlockByNumber but identified by hash.
eth_getUncleByBlockHashAndIndex. Retrieves an uncle block by hash and index position, used in block reward calculations.
eth_getStorageAt. Returns the value from a storage position at a specific address, useful for reading smart contract state.
eth_newFilter. Creates a filter object to listen for events on the blockchain, such as new blocks or transactions.
eth_uninstallFilter. Removes a filter created with eth_newFilter, stopping event listening to reduce resource usage. These APIs are commonly used in dApps that need Ethereum compatibility but require enhanced performance, particularly in applications dealing with microtransactions where minimizing costs is needed. Binance Smart Chain (BNB) API Binance Smart Chain (BSC) runs parallel to Binance Chain, offering smart contract functionality with Ethereum Virtual Machine (EVM) compatibility. Key endpoints include: bnb_getTransactionReceipt. Retrieves the receipt of a transaction, including status, gas used, and logs.
bnb_call. Executes a message call without creating a transaction, similar to Ethereum’s eth_call.
bnb_getBlockByHash. Returns block information based on the block hash.
bnb_getLogs. Fetches logs from BSC smart contracts, similar to Ethereum’s eth_getLogs, and is crucial for event tracking.
bnb_getCode. Retrieves the code at a specific address, helpful for verifying deployed smart contracts.
bnb_estimateGas. Estimates the gas required for a transaction, aiding in cost prediction on BSC.
bnb_getStorageAt. Fetches storage data from a specific contract address, allowing for state reading in smart contracts.
bnb_getTransactionCount. Returns the number of transactions sent from an address, necessary for setting the nonce in new transactions. These endpoints are must-have things for developers building on BSC. Especially those migrating from Ethereum. The bnb_getTransactionReceipt endpoint, for instance, is used to confirm transaction success before updating user interfaces. Hey there! I have been for a long time in dApps developement and I know on my own how it is difficult to get started with blockchain APIs. Especially with their endpoints. I decided to gather the most important endpoints for Ethereum, Binance, Bitcoin, Ploygon, and Solana blockchains in this article. I tried to be consistent and to the point. Hope they will help you! Ethereum API The Ethereum API is fundamental for developers working on the Ethereum network. It provides access to blockchain data, enabling interaction with smart contracts and account management. Key endpoints include: eth_call. Executes a message call immediately without creating a transaction. eth_getTransactionByHash. Retrieves transaction details using its hash. eth_getBlockByNumber. Returns block information by its number. eth_getCode. Retrieves the code at a specific address, useful for checking smart contracts' bytecode. eth_getLogs. Fetches logs from smart contracts, often used to track events like token transfers. eth_estimateGas. Estimates the gas required to execute a transaction, helping developers calculate costs. eth_gasPrice. Returns the current gas price in the network, essential for setting transaction fees. eth_getTransactionCount. Retrieves the number of transactions sent from an address, often used to get the nonce for new transactions. eth_call. Executes a message call immediately without creating a transaction. eth_getTransactionByHash. Retrieves transaction details using its hash. eth_getBlockByNumber. Returns block information by its number. eth_getCode. Retrieves the code at a specific address, useful for checking smart contracts' bytecode. eth_getLogs. Fetches logs from smart contracts, often used to track events like token transfers. eth_estimateGas. Estimates the gas required to execute a transaction, helping developers calculate costs. eth_gasPrice. Returns the current gas price in the network, essential for setting transaction fees. eth_getTransactionCount. Retrieves the number of transactions sent from an address, often used to get the nonce for new transactions. These endpoints are imperative for building dApps that require real-time blockchain data. I mean DeFi platforms and NFT marketplaces. For example, eth_call is used to query token balances in smart contracts without broadcasting a transaction. eth_call Solana API Solana's API is designed for high-speed, scalable applications. This is why Solana is a popular choice for developers focused on performance. Key endpoints include: getRecentBlockhash. Fetches the latest block hash needed for signing transactions. getAccountInfo. Retrieves account data like balance and ownership. sendTransaction. Submits a transaction to the network. getConfirmedBlock. Retrieves information about a specific confirmed block, including all transactions. getConfirmedSignaturesForAddress2. Fetches signatures for confirmed transactions associated with an address. getSupply. Provides the total supply of SOL, the native token of Solana. getProgramAccounts. Returns all accounts owned by a particular program (smart contract). getTokenAccountsByOwner. Retrieves token accounts owned by a specific public key, useful for querying balances of various tokens. getRecentBlockhash. Fetches the latest block hash needed for signing transactions. getAccountInfo. Retrieves account data like balance and ownership. sendTransaction. Submits a transaction to the network. getConfirmedBlock. Retrieves information about a specific confirmed block, including all transactions. getConfirmedSignaturesForAddress2. Fetches signatures for confirmed transactions associated with an address. getSupply. Provides the total supply of SOL, the native token of Solana. getProgramAccounts. Returns all accounts owned by a particular program (smart contract). getTokenAccountsByOwner. Retrieves token accounts owned by a specific public key, useful for querying balances of various tokens. These endpoints support Solana’s proof-of-history (PoH) system, which timestamps transactions to ensure fast processing. For instance, sendTransaction is imperative for executing trades on DEXs built on Solana. There, low latency is crucial. sendTransaction Bitcoin API Bitcoin's API provides essential tools for interacting with the Bitcoin blockchain. They focuse on transaction and wallet management. Key endpoints include: getblockchaininfo. Retrieves the current blockchain state, including block count and difficulty. getrawtransaction. Retrieves detailed transaction information using its ID. getbalance. Returns the balance of a specified wallet address. listunspent. Lists unspent transaction outputs (UTXOs) for a set of addresses, essential for constructing new transactions. sendrawtransaction. Submits a raw transaction (created and signed offline) to the Bitcoin network. getmempoolinfo. Provides information about the nodes' memory pool (mempool), where unconfirmed transactions are held. getblockhash. Retrieves the block hash of a block based on its height, useful for navigating the blockchain. decoderawtransaction. Decodes a raw transaction hex string into a readable JSON object, helping to understand transaction details before broadcasting. getblockchaininfo. Retrieves the current blockchain state, including block count and difficulty. getrawtransaction. Retrieves detailed transaction information using its ID. getbalance. Returns the balance of a specified wallet address. listunspent. Lists unspent transaction outputs (UTXOs) for a set of addresses, essential for constructing new transactions. sendrawtransaction. Submits a raw transaction (created and signed offline) to the Bitcoin network. getmempoolinfo. Provides information about the nodes' memory pool (mempool), where unconfirmed transactions are held. getblockhash. Retrieves the block hash of a block based on its height, useful for navigating the blockchain. decoderawtransaction. Decodes a raw transaction hex string into a readable JSON object, helping to understand transaction details before broadcasting. These endpoints are standard in Bitcoin’s JSON-RPC API and are used in various Bitcoin-related development tasks. The getrawtransaction endpoint, for example, is used to verify transaction details before confirmation in a block. getrawtransaction Polygon API Polygon offers a Layer 2 scaling solution for Ethereum, optimized for lower transaction costs and higher throughput. Key endpoints include: eth_blockNumber. Retrieves the most recent block number. eth_sendTransaction. Sends a transaction to the network with significantly lower gas fees. eth_getLogs. Fetches event logs from the blockchain, useful for tracking smart contract events. eth_getBlockByHash. Fetches block information using the block hash, similar to eth_getBlockByNumber but identified by hash. eth_getUncleByBlockHashAndIndex. Retrieves an uncle block by hash and index position, used in block reward calculations. eth_getStorageAt. Returns the value from a storage position at a specific address, useful for reading smart contract state. eth_newFilter. Creates a filter object to listen for events on the blockchain, such as new blocks or transactions. eth_uninstallFilter. Removes a filter created with eth_newFilter, stopping event listening to reduce resource usage. eth_blockNumber. Retrieves the most recent block number. eth_sendTransaction. Sends a transaction to the network with significantly lower gas fees. eth_getLogs. Fetches event logs from the blockchain, useful for tracking smart contract events. eth_getBlockByHash. Fetches block information using the block hash, similar to eth_getBlockByNumber but identified by hash. eth_getUncleByBlockHashAndIndex. Retrieves an uncle block by hash and index position, used in block reward calculations. eth_getStorageAt. Returns the value from a storage position at a specific address, useful for reading smart contract state. eth_newFilter. Creates a filter object to listen for events on the blockchain, such as new blocks or transactions. eth_uninstallFilter. Removes a filter created with eth_newFilter, stopping event listening to reduce resource usage. These APIs are commonly used in dApps that need Ethereum compatibility but require enhanced performance, particularly in applications dealing with microtransactions where minimizing costs is needed. Binance Smart Chain (BNB) API Binance Smart Chain (BSC) runs parallel to Binance Chain, offering smart contract functionality with Ethereum Virtual Machine (EVM) compatibility. Key endpoints include: bnb_getTransactionReceipt. Retrieves the receipt of a transaction, including status, gas used, and logs. bnb_call. Executes a message call without creating a transaction, similar to Ethereum’s eth_call. bnb_getBlockByHash. Returns block information based on the block hash. bnb_getLogs. Fetches logs from BSC smart contracts, similar to Ethereum’s eth_getLogs, and is crucial for event tracking. bnb_getCode. Retrieves the code at a specific address, helpful for verifying deployed smart contracts. bnb_estimateGas. Estimates the gas required for a transaction, aiding in cost prediction on BSC. bnb_getStorageAt. Fetches storage data from a specific contract address, allowing for state reading in smart contracts. bnb_getTransactionCount. Returns the number of transactions sent from an address, necessary for setting the nonce in new transactions. bnb_getTransactionReceipt. Retrieves the receipt of a transaction, including status, gas used, and logs. bnb_call. Executes a message call without creating a transaction, similar to Ethereum’s eth_call. bnb_getBlockByHash. Returns block information based on the block hash. bnb_getLogs. Fetches logs from BSC smart contracts, similar to Ethereum’s eth_getLogs, and is crucial for event tracking. bnb_getCode. Retrieves the code at a specific address, helpful for verifying deployed smart contracts. bnb_estimateGas. Estimates the gas required for a transaction, aiding in cost prediction on BSC. bnb_getStorageAt. Fetches storage data from a specific contract address, allowing for state reading in smart contracts. bnb_getTransactionCount. Returns the number of transactions sent from an address, necessary for setting the nonce in new transactions. These endpoints are must-have things for developers building on BSC. Especially those migrating from Ethereum. The bnb_getTransactionReceipt endpoint, for instance, is used to confirm transaction success before updating user interfaces. bnb_getTransactionReceipt

Key Endpoints For Blockchain APIs: Ethereum, Bitcoin, Polygon, Binance Smart Chain, And Solana

How I Built an Event Scheduler in NodeJs

আমি কিভাবে NodeJs এ একটি ইভেন্ট শিডিউলার তৈরি করেছি

Wie ich einen Event-Scheduler in NodeJs erstellt habe

Cómo construí un programador de eventos en NodeJs

Comment j'ai créé un planificateur d'événements dans NodeJs

मैंने NodeJs में इवेंट शेड्यूलर कैसे बनाया

NodeJs でイベント スケジューラを構築する方法

NodeJs에서 이벤트 스케줄러를 구축한 방법

Como eu construí um agendador de eventos no NodeJs

Как я создал планировщик событий в NodeJs

NodeJs'de Etkinlik Zamanlayıcısını Nasıl Oluşturdum

Cách tôi xây dựng một trình lập lịch sự kiện trong NodeJs

如何在 NodeJs 中构建事件调度程序

Using Firebase Authentication with the Latest Next.js Features

সর্বশেষ Next.js বৈশিষ্ট্য সহ Firebase প্রমাণীকরণ ব্যবহার করা

Verwenden der Firebase-Authentifizierung mit den neuesten Next.js-Funktionen

Uso de la autenticación de Firebase con las últimas funciones de Next.js

Utilisation de l'authentification Firebase avec les dernières fonctionnalités Next.js

नवीनतम Next.js सुविधाओं के साथ फायरबेस प्रमाणीकरण का उपयोग करना

Usando o Firebase Authentication com os recursos Next.js mais recentes

Использование аутентификации Firebase с новейшими функциями Next.js

Firebase Kimlik Doğrulamasını En Son Next.js Özellikleriyle Kullanma

Sử dụng Xác thực Firebase với các tính năng Next.js mới nhất

将 Firebase 身份验证与最新的 Next.js 功能结合使用

Hey everyone! I recently tackled the task of integrating Webflow OAuth into my app, and as someone who doesn't code, I wanted to share my approach using Xano as a backend and Webflow as a frontend. If you're a coding pro, please bear with me—no throwing rotten tomatoes! This is one no-coder to another, hoping to smoothen your journey a bit. TLDR: I've compiled every step into a video for those who prefer visual learning, but you'll find a detailed text version of the process below. https://youtu.be/bTUatl6eTec?embedable=true Understanding OAuth Let's quickly grasp the fundamental concept of how OAuth operates. Picture this: you're on holiday and want to rent an apartment in a foreign country. You find an apartment building where you can rent a unit. Upon arrival, instead of being given keys to all the flats, the owner sends you a one-time code to access your specific flat's key lockbox. You use this code to open the lockbox and retrieve a key card, granting you access to the apartment during your stay. In this analogy, Webflow represents the apartment owner, the one-time code serves as an access code, and the key card is analogous to an access token. If you need access to any information about a user's Webflow projects—such as lists of pages, assets, collections, or forms—you'll require an access token. This token is used with any API requests sent to Webflow on behalf of the user. In the example below, I'll demonstrate building a simple Webflow app that displays information about the user's project without storing the access token in my database (although in real-world scenarios, it's advisable to store tokens associated with users). Step 1: Create a New Webflow App Navigate to your Webflow dashboard's "Apps & Integrations" tab and create a new app. Provide general information about your app, including its name, description, and home page URL. Specify the required permissions—I'll use a data client app in my example, granting "Read" access to "Sites." You can adjust these permissions later if needed. The crucial pieces of information we need here are the and , automatically generated for your app. Leave the Redirect URL field blank for now; we'll revisit it in the next step. Client ID Client Secret Step 2: Setting Up a New Webflow Project as the Frontend Create a new Webflow project with two pages: Home and Sites. On the Home page, add a button labeled "Show Sites," which will trigger a request to Webflow for the access code. Set the button's URL to , replacing YOUR_CLIENT_ID with the actual Client ID obtained earlier. Adjust the URL if your app requires additional permissions. https://webflow.com/oauth/authorize?response_type=code&client_id=YOUR_CLIENT_ID&scope=sites%3Aread Clicking this button will display a permissions screen to the user, allowing them to choose which projects to grant access to. Upon authorizing the app, they'll be redirected to the Redirect URL—remember to copy the URL of the Sites page (the second page you created) and paste it into the Redirect URL field of your app. Upon completing this step, clicking "Show Sites" will redirect users to the Sites page, with the access code included in the URL. Step 3: Setting Up a Xano Project and Creating the First API Create a new project in Xano, and navigate to the APIs tab. Add a new API Group, and then within that group, add a new API Endpoint—let's call it "getToken." In the "getToken" endpoint: Add a text input named "accessCode" to receive the access code from the frontend. Make a POST request to with body parameters: https://api.webflow.com/oauth/access_token client_id: Your Client ID client_secret: Your Client Secret grant_type: authorization_code code: accessCode (using the variable from the input) Define the output of the first API request as "accessToken," which will be the access token associated with the user. Make a second API request (for demonstration purposes) to retrieve the user's site list—a GET request to . Include the following headers: https://api.webflow.com/v2/sites accept: application/json authorization: accessToken.response.result.access_token Define the output of the second API as "siteList," which represents the list of Webflow projects. Return the "siteList" in the response. Copy the API endpoint URL for later use. Step 4: Configuring a Frontend Request From Your Webflow Project Return to the Webflow project and open the Sites page—the page where users are redirected after granting access to their Webflow projects. Here, add the following JavaScript functions in the custom code area before the </body> tag. First, let's create the function to retrieve the sites: getSites() function getSites() {
 const url = window.location.search;
 const params = new URLSearchParams(url);
 const accessCode = params.get('code');
 const options = {
 method: 'POST',
 headers: {accept: 'application/json', 'content-type': 'application/json'},
 body: JSON.stringify({accessCode: accessCode})
 };
 fetch('YOUR_API_ENDPOINT', options)
 .then(response => response.json())
 .then(response => {
 const siteList = response.response.result.sites;
 showSites(siteList);
 })
 .catch(err => console.log(err));
} Then, let's create the function to display the retrieved sites: showSites() function showSites(sites) {
 const container = document.querySelector('#result');
 sites.forEach(site => {
 const siteDiv = document.createElement('div');
 siteDiv.classList.add('site');
 const siteContent = 
 `<h2>${site.displayName}</h2>
 ID: ${site.id}
 Workspace ID: ${site.workspaceId}
 Short Name: ${site.shortName}
 Time Zone: ${site.timeZone}
 Created On: ${site.createdOn}
 Last Updated: ${site.lastUpdated}
 Last Published: ${site.lastPublished}
 <img src="${site.previewUrl}" alt="Preview">
 `;
 siteDiv.innerHTML = siteContent;
 container.appendChild(siteDiv);
 });
} Lastly, ensure that the function runs on page load: getSites() document.addEventListener('DOMContentLoaded', function() {
 getSites();
}); And there you have it! I hope this guide proves helpful for my fellow no-coders! Feel free to reach out if you have any questions or need further clarification. Happy coding!

No-Code Webflow OAuth: Make Authenticated Requests to the Webflow API Using Xano

নো-কোড ওয়েবফ্লো OAuth: Xano ব্যবহার করে Webflow API-তে প্রমাণীকৃত অনুরোধ করুন

No-Code-Webflow-OAuth: Stellen Sie mit Xano authentifizierte Anfragen an die Webflow-API

Webflow OAuth sin código: realice solicitudes autenticadas a la API de Webflow utilizando Xano

No-Code Webflow OAuth : effectuez des requêtes authentifiées à l'API Webflow à l'aide de Xano

नो-कोड वेबफ़्लो OAuth: Xano का उपयोग करके वेबफ़्लो API के लिए प्रमाणित अनुरोध करें

ノーコード Webflow OAuth: Xano を使用して Webflow API への認証済みリクエストを行う

코드 없는 Webflow OAuth: Xano를 사용하여 Webflow API에 인증된 요청 만들기

No-Code Webflow OAuth: Faça solicitações autenticadas para a API Webflow usando Xano

OAuth Webflow без кода: выполнение аутентифицированных запросов к API Webflow с помощью Xano

Kodsuz Webflow OAuth: Xano Kullanarak Webflow API'sine Kimliği Doğrulanmış İstekler Yapın

OAuth luồng web không mã: Thực hiện các yêu cầu được xác thực đối với API luồng web bằng Xano

无代码 Webflow OAuth：使用 Xano 向 Webflow API 发出经过身份验证的请求

Hello everyone! Reading emails in automated tests is a trick that you might need to know how to do in a lot of the projects. Here’s why and how to deal with it… Why Is This Important? Well, if the system sends emails - you might want to verify that they are being sent and the content is right, including clickable links. So these are the usual scenarios when you need this: Sign up. A lot of platforms send a confirmation email once you create an account, and you need to click a confirmation link from the email. Invoices. If your app does any payments - they usually send a cheque or invoice via email, so you might want to see if their contents are correct too. Results. Like medical test results. In my experience - some hospitals send an email with test results once they are done (or at least a link to a personal page where you can view the report). … Of course, this is not the complete list - these are just the use cases I’ve met the most in my career. Failing to verify these scenarios might lead to users not getting emails or getting the wrong information in emails. In one of the projects, it helped us find early an expired token. SendGrind What Are the Complications of Reading Emails in Tests? Reading emails is a tricky thing to do, but not an impossible one. Early email clients were using to fetch emails from the server, but there’s a small problem - it deletes the emails from the server once they are downloaded. POP3 Later, protocol came in - it allows you to simply read emails from the server. IMAP The problem is - or when you connect for the first time (like when you restart an automated test). some services ban these protocols make you confirm your identity On the other hand, some services like provide a to manipulate your emails, but there’s another problem - the documentation and its libraries are not really that user-friendly (especially for those who don’t work with email testing much). Gmail REST API This is where comes in - an library that allows you to read emails and even open them in your browser if you use browser automation tools like . gmail-getter npm Playwright Reading Gmail Emails With Gmail-Getter First thing first - you need to install the package in your project: npm install gmail-getter Create a Google Cloud Console Project, and Obtain Credentials To log into you need to obtain credentials: a , a , and a . These credentials let you get an Access token, which is required in further requests (like getting a list of emails or a single email, etc.). Gmail API, Client ID Client Secret Refresh token Steps to go: Create a project in . Google Cloud Console Create in the section ( ) and download it. OAuth credentials API & Services preferably, select app there if you need it for automated tests Desktop Enable the . Gmail API Obtain a Refresh token. To get a Refresh token - simply execute a command in a project root: npx gmail-getter get-refresh-token (or anywhere else if you've got the package installed globally) get-refresh-token You must put the file in a place where you will execute the command. credentials.json ⚠️ credentials file name is case-sensitive ⚠️ Obtain Access Token Once the configuration is done, you must get an Access token in your automated tests. I’d say that the best place for it is a global setup (a function that executes before the test run starts). So, it’ll be something like this: import {getToken} from 'gmail-getter'

export default async function globalSetup() {
 process.env['ACCESS_TOKEN'] = await getToken(
 process.env.CLIENT_ID!,
 process.env.CLIENT_SECRET!,
 process.env.REFRESH_TOKEN!
 )
} The example above uses environment variables, for which you will definitely need to install the package as well. dotenv But, if you wanna keep things simple - you can use this snippet wherever you need the token to be accessible from: const accessToken = await getToken(
 '<put-your-client-id-here>',
 '<put-your-client-secret-here>',
 '<put-your-refresh-token-here>'
 ) Get Emails Right now, uses to find the email you need: Gmail’s REST API its own query language const email = await checkInbox(accessToken!, 15000, 1500, 'from:squier7 subject:Test!') The command above returns you an email object, but you still need to get either its contents or a link. Replace to your own query following the syntax from the link above ☝️ from:squier7 subject:Test! You can parse a link using : a regex const link = parseLinkFromHtml(email!, /(https:\/\/)(\S*)(gmail-getter)([\w\/\?\=\-]*)/im) Replace with your own regular expression ☝️ /(https:\/\/)(\S*)(gmail-getter)([\w\/\?\=\-]*)/im OR get the whole HTML content of the email, and render it in your browser: import {getToken, parseHtml} from 'gmail-getter'
import {test} from '@playwright/test'

test('Render an email', async ({page}) => {
 const accessToken = await getToken(
 '<put-your-client-id-here>',
 '<put-your-client-secret-here>',
 '<put-your-refresh-token-here>'
 )

 const email = await checkInbox(accessToken!, 15000, 1500, 'from:squier7 subject:Test!') // get an email
 const html = parseHtml(email!) // parse HTML from the email
 await page.setContent(html) // render the email in the browser
}) Overall I think it’s pretty obvious now that working with emails in automated tests might be tricky! But knowing these tricks makes things much easier. You might still go through some other email services or try , but I guarantee you - it won’t be as easy as it is in this guide, as you’d need to create a helper of your own, like provided here. IMAP gmail-getter You can find the on . too. Playwright example GitHub Cypress example

How to Read Gmail Emails With Playwright

নাট্যকারের সাথে জিমেইল ইমেলগুলি কীভাবে পড়বেন

So lesen Sie Gmail-E-Mails mit Playwright

Cómo leer correos electrónicos de Gmail con Playwright

Comment lire les e-mails Gmail avec Playwright

नाटककार के साथ जीमेल ईमेल कैसे पढ़ें

Playwright で Gmail メールを読む方法

극작가와 함께 Gmail 이메일을 읽는 방법

Como ler e-mails do Gmail com o Playwright

Как читать электронные письма Gmail с помощью драматурга

Oyun Yazarı ile Gmail E-postaları Nasıl Okunur?

Cách đọc email Gmail với nhà viết kịch

如何使用 Playwright 阅读 Gmail 电子邮件

Introduction Angular is a popular front-end framework used for building dynamic web applications. One of its essential features is making API requests to fetch and manipulate data from external sources. However, doing this correctly is crucial to ensure your application's performance, security, and maintainability. In this comprehensive guide, we will dive into the best practices for handling API requests in . Angular Understanding API Requests What Are API Requests? API, which stands for Application Programming Interface, is a set of rules that allows different software applications to communicate with each other. API requests, in the context of web development, involve sending and receiving data between a client (your ) and a server (the external data source) using HTTP protocols. Angular application In Angular, you often make API requests to retrieve data from servers, update information, or perform other actions such as authentication and authorization. These requests can be of various types, including GET (retrieve data), POST (send data), PUT (update data), and DELETE (remove data). Why Proper API Request Handling Matters Properly handling API requests is essential for several reasons: Inefficient API requests can slow down your application. Optimized requests ensure a smooth user experience. Performance: Securely handling requests prevents vulnerabilities like cross-site scripting (XSS) and cross-site request forgery (CSRF). Security: Well-organized API request code is easier to maintain and scale as your application grows. Maintainability: Handling errors gracefully helps you provide informative feedback to users. Error Handling: Now, let's explore the best practices for making API requests in Angular. Best Practices for API Requests in Angular 1. Organize Your Code Follow the MECE (Mutually Exclusive, Collectively Exhaustive) principle to organize your API request code. Group related API requests into services and keep them separate from component logic. This makes your codebase more structured and maintainable. // Example of an API service
@Injectable({
 providedIn: 'root',
})
export class DataService {
 constructor(private http: HttpClient) {}

 getPosts(): Observable<Post[]> {
 // API request logic
 }

 createPost(newPost: Post): Observable<Post> {
 // API request logic
 }
} 2. Use Angular's HttpClient Angular provides the module for making HTTP requests. Use it instead of the older module, as offers features like strong typing and interceptors for handling requests and responses. HttpClient Http HttpClient import { HttpClient } from '@angular/common/http';

constructor(private http: HttpClient) {} 3. Set a Base URL Define a base URL for your API requests to avoid repeating the same URL in multiple places. You can set this in your environment configuration for flexibility between development and production environments. // environment.ts
export const environment = {
 production: false,
 apiUrl: 'https://api.example.com',
}; // Service
import { environment } from 'src/environments/environment';

@Injectable({
 providedIn: 'root',
})
export class DataService {
 private apiUrl = environment.apiUrl;

 constructor(private http: HttpClient) {}

 // Use this.apiUrl when making requests
} 4. Use RxJS Observables Angular leverages RxJS Observables to handle asynchronous data streams. Embrace Observables when making API requests to manage data flow effectively and handle events like data updates and errors. getPosts(): Observable<Post[]> {
 return this.http.get<Post[]>(`${this.apiUrl}/posts`);
} 5. Implement Error Handling Always include error handling in your API requests. You can use the operator to gracefully manage errors and provide meaningful feedback to users. catchError import { catchError } from 'rxjs/operators';
import { throwError } from 'rxjs';

getPosts(): Observable<Post[]> {
 return this.http.get<Post[]>(`${this.apiUrl}/posts`).pipe(
 catchError((error) => {
 // Handle the error and optionally log it
 console.error('API Error:', error);
 return throwError('Something went wrong. Please try again later.');
 })
 );
} 6. Use Interceptors are middleware functions that can preprocess requests and responses globally. You can use interceptors for tasks like adding headers, handling authentication, or logging requests. Angular interceptors @Injectable()
export class AuthInterceptor implements HttpInterceptor {
 constructor(private authService: AuthService) {}

 intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
 // Add authentication token to the request headers
 const token = this.authService.getToken();
 if (token) {
 request = request.clone({
 setHeaders: {
 Authorization: `Bearer ${token}`,
 },
 });
 }

 return next.handle(request);
 }
} 7. Optimize HTTP Requests To optimize your application's performance, reduce unnecessary HTTP requests by caching data when appropriate, and use techniques like lazy loading for modules that make API requests. 8. Implement Pagination and Filtering For large datasets, implement pagination and filtering on the server side to minimize the amount of data transferred in each request. Pass pagination and filtering parameters in your API requests. 9. Secure Sensitive Data When dealing with sensitive data, use HTTPS for secure communication and ensure your server-side endpoints are properly secured with authentication and authorization mechanisms. FAQ Q1: What is the difference between HttpClient and Http in Angular? A1: HttpClient is the recommended module for making HTTP requests in Angular, offering features like strong typing and interceptors. HTTP is the older module, and its use is discouraged. Q2: How do I handle authentication in API requests? A2: You can handle authentication by using interceptors to add authentication headers to your requests. Ensure that your server-side endpoints also implement authentication mechanisms. Q3: What is the purpose of error handling in API requests? A3: Error handling allows you to gracefully handle errors that may occur during API requests and provide informative feedback to users. Conclusion Mastering API requests in Angular is crucial for building efficient, secure, and maintainable web applications. By following best practices like organizing your code, using Angular's HttpClient, and implementing error handling, you can ensure your application communicates with external data sources effectively. Remember to optimize your requests, handle sensitive data securely, and always keep the user experience in mind. With these principles in mind, you'll be well on your way to creating robust Angular applications. Also published . here

Mastering API Requests in Angular: Best Practices for Efficient, Secure, and Maintainable Web Apps

Blockchain technology has sparked the emergence of a whole new industry widely known as “Web3”, a new frontier in the digital economy where decentralization, interoperability and user empowerment are put front and center. As part of the Web3 dawning, multiple new asset classes are becoming available to the masses. Cryptocurrencies such as Bitcoin and Ethereum are a well-known staple of web3 assets, but since the rise of Decentralized Finance and NFT’s the variety of blockchain-based asset classes is rapidly increasing. With this increased complexity in Web3-assets users are looking for convenient ways to keep track of their assets across blockchains and Web3 protocols. Enter the , a convenient platform that connects to a Web3-wall and provides a comprehensive overview of its balances and positions: Portfolio Tracker et In this article we will provide a step-by-step walkthrough for web3 and web3-curious developers to build their own portfolio tracking feature, using the free-to-use . DeCommas’ Mission Control API What is DeCommas “Mission Control API”? DeCommas’ API is a developer-friendly API providing fast and convenient access to structured blockchain data. On developers can get access to free API-keys in a matter of seconds, providing access to one of the fastest cross-chain Web3 API’s out there. https://build.decommas.io/ As a developer you can access and query the data stored on multiple blockchains with blazing fast response times of below 150ms, free of charge. There’s no need to duplicate multiple API-calls either, as the API response is cross-chain by default. Recently the DeCommas team has doubled down on the OP Stack, adding support for opBNB and Base L2’s as well. In case you are curious about the API, full documentation is available . here Tutorial: Building a Portfolio Tracker using Mission Control API For this tutorial we’ll help you on your way building a Portfolio Tracking feature. We’ll use Mission Control API, and make use of endpoints to fetch ERC20-balances, NFT holdings and even Protocol Positions. In this tutorial, we’ll: Show you how to get your Mission Control API key Set up Mission Control API in your environment Learn about the API call and it’s response Create fundamental features for your portfolio tracker Let’s dive in! Get your personal Mission Control API key DeCommas Mission Control API is required for completing this tutorial. It’s free to use, supports cross-chain queries by default and achieves extremely high response times. Gaining access is simple: Head to https://build.decommas.io/ Click “Get Started” Enter your email address Check your email and click the link to sing in You will now be able to access , which contains your API keys https://dashboard.decommas.io/ You will need your API keys for completing this tutorial, so go ahead and copy paste these to some place where they are easy to find for you, but securely stored. For this tutorial, DeCommas documentation will also come in handy: https://docs.decommas.io/ Setting up Mission Control API in your environment Depending on your preferences, you can interact with the API either via a raw HTTPS request or in JavaScript using our SDK. In case you go with the first route, the call would look like this: https://datalayer.decommas.net/datalayer/api/v1/tokens/{address}?api-key={YOUR-API-KEY} For this tutorial however, we’ll be using the JavaScript SDK that’s provided, and we’ll be using the Quick Start guide to get Mission Control API initiated in your environment. DeCommas SDK: https://github.com/DeCommas/decommas-sdk Install the Mission Control API application in your Javascript environment npm install @decommas/sdk 2.After installing the app you can import and use the SDK: import { Decommas } from '@decommas/sdk';

// Allows to use SDK in DEV-ONLY mode
const decommas = new Decommas();

const getVitalikERC20Balances = async () => {
const address = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'; // any address

const tokens = await decommas.address.getTokens({ address });
console.log(tokens);
}; You are now all set, and are ready to call the API! Building fundamental Portfolio Tracker features Now you are familiar with the and can access the API, let’s build some real world features! SDK A good Portfolio Tracker needs to provide insights in ERC-20 holdings, the value of these holdings and a user's transaction history. We’ll give you a primer on all 3 of these! 1. Fetch current ERC-20 balances for a wallet In order for a user to know what and how many  ERC-20 tokens they possess, we’ll be using the once more. ERC-20 tokens endpoint By providing the user's wallet address to the API call, the API returns an overview of ERC-20 tokens across all supported networks. In this case, for wallet address 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 the API will return an array of tokens together with their corresponding balances. The API will respond with a clean array containing tokens, the chains they’re on and their respective balances. You can use this data to provide an overview in your Portfolio Tracker, for example by showing a list of tokens a user holds, sorted by the total amount of each token. {
  "count": 2,
  "status": 200,
  "result": [
    {
      "chain_name": "mainnet",
      "chain_id": 1,
      "address": "0x228ba514309ffdf03a81a205a6d040e429d6e80c",
      "name": "Global Social Chain",
      "decimals": 18,
      "symbol": "GSC",
      "logo_url": "https://assets.coingecko.com/coins/images/4304/large/global-social-chain.png?1547742843",
      "actual_price": "0.00147295",
      "is_verified": true,
      "is_stable": false,
      "amount": "20000000000000000000"
    },
    {
      "chain_name": "mainnet",
      "chain_id": 1,
      "address": "0x38e4adb44ef08f22f5b5b76a8f0c2d0dcbe7dca1",
      "name": "Concentrated Voting Power",
      "decimals": 18,
      "symbol": "CVP",
      "logo_url": "https://assets.coingecko.com/coins/images/12266/large/Powerpool.jpg?1598621373",
      "actual_price": "0.433299",
      "is_verified": true,
      "is_stable": false,
      "amount": "42130000000000000000"
    }
  ]
} 2. Report value of ERC-20 tokens in USDC While knowing how much of a token a user possesses is valuable information, many users would like to see the value of their holdings expressed in USD. Let’s take another look at the response from the ERC-20 Tokens endpoint: {
  "count": 2,
  "status": 200,
  "result": [
    {
      "chain_name": "mainnet",
      "chain_id": 1,
      "address": "0x228ba514309ffdf03a81a205a6d040e429d6e80c",
      "name": "Global Social Chain",
      "decimals": 18,
      "symbol": "GSC",
      "logo_url": "https://assets.coingecko.com/coins/images/4304/large/global-social-chain.png?1547742843",
      "actual_price": "0.00147295",
      "is_verified": true,
      "is_stable": false,
      "amount": "20000000000000000000"
    },
    {
      "chain_name": "mainnet",
      "chain_id": 1,
      "address": "0x38e4adb44ef08f22f5b5b76a8f0c2d0dcbe7dca1",
      "name": "Concentrated Voting Power",
      "decimals": 18,
      "symbol": "CVP",
      "logo_url": "https://assets.coingecko.com/coins/images/12266/large/Powerpool.jpg?1598621373",
      "actual_price": "0.433299",
      "is_verified": true,
      "is_stable": false,
      "amount": "42130000000000000000"
    }
  ]
} Using the variable “actual_price”, you can show the user the sum of their holdings expressed in USD.  Depending on what you have in mind for your Portfolio Tracker, you could consider showing the amount of tokens by token, combined with a total USDC value the user has in that token. For this you can use “Name”, “Symbol”, “Amount” and “Actual Price”. Wrapping up - Your first steps to building your web3 Portfolio Tracker This is of course just a start for building your Portfolio Tracker. Want to learn more about expanding your Portfolio Tracker? Keep an eye out on DeCommas’ , as new web3 tutorials are posted frequently! HackerNoon Getting started in web3 development might feel daunting, but by using DeCommas’ Mission Control API you can speed up the process tremendously. Utilizing just a few straightforward API calls already gets you access to heaps of blockchain-stored data, free of charge. Enjoyed this Tutorial and want to learn more? Give DeCommas a follow on , where we regularly post Web3 Development tutorials just like this one! Already know all that you need and want to build on? Head out to and use Mission Control API to your advantage! HackerNoon build.decommas.io Also published . here

Creating a Web3 Portfolio Tracker with DeCommas API

Creación de un rastreador de cartera Web3 con la API DeCommas

Création d'un suivi de portefeuille Web3 avec l'API DeCommas

DeCommas API के साथ एक Web3 पोर्टफोलियो ट्रैकर बनाना

DeCommas API を使用した Web3 ポートフォリオ トラッカーの作成

Criando um rastreador de portfólio Web3 com API DeCommas

Tạo Trình theo dõi danh mục đầu tư Web3 bằng API DeCommas

使用 DeCommas API 创建 Web3 投资组合跟踪器

Stories, News & Mentions about GMTTOKEN

Gmttoken’s Stories on HackerNoon