Martin has been writing on cyber security and infotech for two decades. He has previous forex trading experience and has been covering the blockchain and crypto industry since 2017.
The tragic combination of inevitable bugs and immutable code
Last week witnessed a catastrophic event in the Ethereum ecosystem, when The DAO, a smart contract less than two months old, began rapidly leaking funds to an unknown party. Looking at the current set of Ethereum contracts, filled with casinos and self-declared Ponzi schemes, this might not seem like a big deal. That is, until you learn that over 12 million units of ether, the Ethereum cryptocurrency, had been invested in The DAO by almost 20,000 people. That’s around 15% of all the ether in existence, valued at over $250 million on June 17th.
Two days later, The DAO’s assets dipped below $100 million. Two things contributed to this precipitous fall. First, a third of its funds (as denominated in ether) had already been taken. And second, the resulting panic sent the market price of ether crashing down from its peak of over $21 to a more sobering $10.67. (At the time of publication, the price had recovered to around $14.) This second effect was a natural consequence of the first, since much of ether’s recent increase in value was driven by people buying it to invest in The DAO.
The DAO had promised to act as a new type of decentralized crowdsourcing vehicle, like Kickstarter or Indiegogo but without the middleman and regulation. It was designed to let participants pool their cryptocurrency, collectively vote on projects looking for funding, then invest and reap the future rewards. Before catastrophe struck, over 100 projects had already been proposed, most of which were related to Ethereum itself. In addition, The DAO allowed participants to withdraw their uninvested funds at any time, positioning itself as a low risk investment.
Ironically, the individual or group which drained The DAO did so by exploiting subtle errors in this withdrawal mechanism. Like all smart contracts in Ethereum, The DAO is just a piece of computer code, which is “immutably” (i.e. permanently and irreversibly) embedded in the blockchain and executed by every node in response to incoming transactions. And like any self-respecting smart contract, The DAO provides full transparency by making its source code easily accessible online. This means that anybody can independently verify its functionality but also, crucially, look for vulnerabilities. And yet, the immutable nature of blockchains prevents any such problems from being fixed.
At the end of May, several critical issues were highlighted on the outstanding Hacking Distributed blog, alongside a call for a moratorium on project proposals for The DAO. This is what we might call the ‘white hat’ approach, in which exploits are reported for the good of the community. Nonetheless nobody seemed too worried, as the problems related to skewed economic incentives rather than a risk of outright theft. Simultaneously, however, it appears that others were poring over The DAO’s code with greater self-interest – namely, to look for a way to make a ton of money. And on June 17th, someone succeeded.
Draining The DAO
In a general sense, the attack arose from the interaction between vulnerabilities in The DAO’s code and other code which was designed to exploit them. You see, when looked at in isolation, The DAO did not contain any obvious mistakes, and indeed it was only released after an extensive security audit. But with the benefit of hindsight and many more eyes, a significant number of errors have since been found.
I won’t provide a full technical description of the exploit’s mechanism here, since others have already published superb and detailed post mortems (see here, here and here). But I will explain one particular vulnerability that was present, because it has been discovered in many other smart contracts and serves as an instructive example.
Let’s say that a smart contract holds funds on behalf of a number of users, and allows those users to withdraw their funds on request. The logic for the process might look something like this:
- Wait for a user to request a withdrawal.
- Check if that user’s balance is sufficient.
- If so, send the requested quantity to the user’s address.
- Check that the payment was successful.
- If so, deduct the quantity from the user’s balance.
This all looks eminently sensible, and rather like an ATM which gives you some cash and deducts the appropriate amount from your bank balance.
So how can this simple process go wrong? Well, it turns out that if an Ethereum address belongs to a contract rather than a regular user, then this contract can run some code in response to receiving funds. And this code can, in turn, trigger other pieces of code on the Ethereum blockchain. Crucially, it can even trigger the same piece of code that caused it to be paid in the first place.
This means that, during step 3 above, the receiving address can send a new request for withdrawal, beginning a new process at step 1 before the previous process has completed. Since the user’s balance is only reduced in step 5, a new withdrawal will be approved based on the previous balance, and the same amount will be paid out again. In response to this second payment, the receiving contract can request a third, and then a fourth, and so on until the funds are drained or some other limit is reached. At this point, the user’s balance will finally be reduced by the appropriate amount, entering the negative territory which step 2 was supposed to prevent.
The equivalent would be an ATM which delivers banknotes that trigger a free repeat withdrawal when waved at the screen. The first customer to find out could empty the ATM entirely.
This ability for a piece of code to wind up calling itself is called recursion, and is a very useful technique in general computer programming. However in the case of The DAO, it paved the way for this ruinous exploit. Nonetheless, if this had been the only problem, the attack’s potential would have been contained, because Ethereum applies a limit on how deeply recursion can occur. Unfortunately, several further bugs in The DAO amplified the effects, leading to the eventual loss of tens of millions of dollars.
Of course, if just a few lines of The DAO’s code had been written differently, none of this could have happened. For example, in the 5-step process above, if the user’s balance is reduced before the funds are sent, then recursive calling would be perfectly safe. But sadly, even if its creators’ intentions were pure, The DAO’s actual code was deeply flawed. And computers have a nasty habit of blindly following the instructions they are given, even if a five year old can see that the results don’t make sense. Having been embedded immutably in the Ethereum blockchain, the faulty DAO was granted stewardship over hundreds of millions of dollars by a horde of naïve investors, and then spectacularly went up in flames. The DAO turned out to be a complete and utter shambles, and it can never be fixed.
The trouble with code
Tempting as it might be, I’m not here to haul The DAO’s programmers over the technical coals. Looking at the underlying source code, it seems reasonably well architected, with good function and variable names and clear internal documentation. While none of this proves its quality, there tends to be a high correlation between how code looks and how well it functions, for the same reason that CVs with poor punctuation warn of sloppy employees. In any event I don’t doubt that The DAO’s authors are competent developers – indeed, the fact that it passed an extensive code review suggests that the basic logic was sound.
So if the problem is not the people who worked on this project, or the work they produced, what is it? It is the fact that writing large pieces of bug-free code is extremely hard, if not impossible. I’ve worked with some truly outstanding programmers in my career, the sort who can crank out code at ten times the average developer’s pace, and with ten times fewer defects. And yet, even these remarkable individuals make mistakes which lead to software malfunctions. Donald Knuth, possibly the greatest computer programmer of all time, made a famous promise to provide an exponentially increasing financial reward to each person who found a bug in his TeX typesetting software. And he’s sent out more than a few checks.
To be clear, I’m not talking about silly slip-ups with names like “off-by-one”, “uninitialized variable” and “operator precedence”. These often cause a visible failure the first time a program is run, and can be easily spotted by reviewing the local piece of code in which they reside. And I’m not even talking about security vulnerabilities like “unvalidated inputs”, “SQL injection” and “buffer overflows”, which might not show up in a program’s regular usage, but should nonetheless be front of mind for every experienced developer.
Rather, I’m talking about trickier problems like “race conditions” and “deadlocks”. These arise from conflicts between parallel processes and tend to only show up intermittently, making them hard to detect and reproduce. As a result, they can only be understood by considering a system as a whole and how its constituent parts interact. This is much harder than regular programming, because it requires developers to think beyond the individual piece of code that they’re working on. It’s not unusual for coders to spend several days “debugging” in order to nail one of these problems down. And this is precisely the sort of holistic thinking that was needed to foresee how The DAO might be vulnerable.
With all of these difficulties, one might legitimately wonder why our increasingly code-driven world isn’t crumbling around us. Luckily, most software has three critical factors working in its favor – gradual adoption, regular updates and time.
Here’s how it works: A new software product is created to answer an emerging market need. At first, the market is small, so only a few people know they need the product. And since the product is new, an even smaller number of them will actually find it. These “early adopters” are a brave and hardy bunch who enjoy living on the technological edge, despite the associated risks. So they try out the new product, see some stuff they like, ask for a bunch of things that are missing and, best of all, report any problems encountered. Every good software entrepreneur knows to shower these people with love and assistance, and thank them for every single morsel of feedback they provide. Because while it sucks to hear about a defect in your product, it sucks a lot more not to hear about it.
Ideally, within a month or less, a new version of the product is released, fixing the reported bugs and adding some requested features. The early adopters are happy and more feedback flows in, as the latest version is put through its paces, and round it goes again. As the market grows, the number of people using the product increases. And as the product steadily improves, more and more of these people tell others about it. Even better, the more people that use the product, the more likely it is that someone, somewhere, will create that precise and unlikely situation in which an obscure bug will appear. With a bit of luck, they will let you know, and you will scratch your head in disbelief, ask for more information, eventually find and resolve the problem, and breathe a sigh of relief.
With few exceptions, this is how today’s software development works, because it is the most efficient way to create outstanding products. Of course, a good software team will also develop an extensive internal test suite, to catch as many errors as possible before they reach users, and ensure that new versions don’t break anything that previously worked. But still, most of us also rely on our user bases, because there is simply no way that we can afford to imagine and test every possible way in which our products might be used. And if you think this doesn’t apply to the big guys, you couldn’t be more wrong. How many “automatic updates” have been downloaded to your Windows, Mac or Linux system in the past year? And if you’re using Chrome or Firefox, your web browser now updates itself automatically and silently, an average of once per month.
This iterative process takes considerable time, by which I mean a few years or more. Still, after a product has been in development for long enough, and its user base has grown large enough, and those users have been (unknowingly) testing it in enough different situations, something magic happens. This magic is called “maturity”, and it’s what every software product must strive to achieve. Maturity means that a product works really well for pretty much everybody that uses it, and there are no shortcuts to getting there. But if you get the timing right, your product will mature at around the time that your target market coalesces, i.e. when large numbers of customers are actually willing to stump up and pay for it. And then, as they say, verily shall ye profit.
On immutable code
So here we come to the fundamental problem with smart contracts, as demonstrated so forcefully by The DAO:
By design, smart contracts are immutably embedded in a blockchain, and so cannot be updated. This prevents them from reaching maturity.
In previous posts, I’ve discussed other problems with smart contracts, such as their effect on blockchain performance and the fact that they are less powerful than many people imagine. For these and other reasons, we have not (yet) implemented smart contracts in the MultiChain blockchain platform. But until I witnessed the failure of The DAO, I hadn’t given enough thought to a much more fundamental issue: any non-trivial smart contract is likely to contain defects that cannot be fixed.
For the modern software developer, unfixable code is an out-and-out nightmare, setting the bar higher than most are able to reach. But we do encounter this kind of code in some situations, such as the design of the microprocessors which lie at the heart of every computer and smartphone. This code, written in languages like Verilog and VHDL, defines the physical layout of a silicon chip, which cannot be changed once manufactured. In situations like these, we tend to see several characteristics: (a) the code is written in a language that was designed with safety in mind, (b) large numbers of people work on it for several years, (c) it is subject to extensive automated testing and formal verification, and (d) if the final product is shipped with a defect, the cost of a recall falls squarely on the shoulders of the party responsible (see for example the infamous Pentium bug).
It goes without saying that none of this applies to the creators of The DAO, or indeed any other smart contract. But code immutability isn’t the only challenge for smart contract developers. A number of other factors conspire to make Ethereum considerably more dangerous than most computing environments:
- As discussed earlier, most contracts reveal their source code, to gain the trust of potential users. This makes bugs easy to find and exploit. While regular code can be fixed when a problem is found, with immutable code only attackers get to benefit.
- As in most programming languages, one “function” (piece of code) on the blockchain is able to “call” (trigger) another, to create cascading effects. However Ethereum is unusual in enabling direct function calls between the code written by parties who do not know each other and whose interests may collide. This is a perfect recipe for adversarial and unexpected behavior.
- As mentioned previously, if one Ethereum contract sends funds to another, the latter has the opportunity to execute some code in response. This code can be deliberately designed to cause the send operation to fail, potentially triggering all sorts of further havoc.
- When one function calls another, and this second function calls a third, a “stack” of calls and sub-calls is created. Keeping track of this stack carries a computational cost, so Ethereum includes a “call stack limit” which restricts how deep it can go. This is fair enough. But if the limit is reached by a particular function call, the Ethereum environment silently skips that call, rather than safely terminating the entire transaction and unwinding its effects. In other words, some code in a smart contract just might not be executed, and this non-execution can be deliberately caused by triggering that contract from a sufficiently deep stack. This strikes me as a truly abominable design choice, breaking the mental model that every software developer is accustomed to. Whoever made this decision probably should be hauled over the coals, though there is thankfully now a suggestion to change it.
- Ethereum also has a “gas limit”, which prevents abuse in public blockchains by making transactions pay for the computational resources they consume. The sender of a transaction decides how much gas they are willing to spend, and if this runs out before the transaction completes, it is safely aborted. While this is probably the best solution to a difficult problem, it can have unpleasant consequences. Some contracts turn out to need more gas than anticipated, while others cannot be run at all.
- The public Ethereum network’s cryptocurrency allows defects in smart contracts to send real money to the wrong place, with no easy method of recovery. While Ethereum miners seem to be voting in favor of a “soft fork” to freeze the funds drained from The DAO, this is not a sustainable solution.
To summarize, compared to regular centralized computer systems, Ethereum is a much more tricky environment to code for safely. And yet its principle of immutability serves to prevent buggy software from being updated. In other words, smart contracts are software whose bugs are visible, cannot be fixed, and directly control real people’s money. This, rather obviously, is a highly toxic mix.
Proponents of Ethereum-style smart contracts in private blockchains might be tempted to celebrate The DAO’s demise, but I don’t think this response is merited. With the exception of the last two points above, all of the issues with Ethereum apply equally to permissioned blockchains, which still rely on immutable smart contracts – although in this case the immutability is guaranteed by a group of identified parties rather than anonymous miners. If you want to claim that private blockchains allow buggy smart contracts to be more easily rewound, replaced or ignored, then what you’re really saying is that smart contracts serve no purpose in these blockchains at all. Put simply, if something is not meant to be immutable, it shouldn’t be stored in a blockchain. Instead, stick to good old fashioned legal documents and centralized application logic, using the chain for: (a) immutably storing the data on which that logic depends, and (b) representing the final consensual outcome of applying it. (This design pattern has been named Simple Contracts by others.)
Nonetheless the risks in the public Ethereum network are undoubtedly worse, because badly written smart contracts can rapidly and irreversibly send large amounts of real value (in the form of cryptocurrency) to users whose identity is unknown. Indeed, is there any better way for an evil genius to make a killing than: (a) writing a smart contract which looks right and fair, (b) allowing it to run safely and consistently for several years, (c) waiting for it to accumulate a large sum of money from investors, and then (d) triggering some obscure vulnerability to siphon off those funds. While I’m not suggesting that The DAO’s failure was deliberate, it will surely inspire others to make similar “mistakes”.
If I had to summarize the factors underlying Ethereum’s design, I might use the phrase “inexperienced genius”. Genius, because I believe it is a genuinely brilliant invention, adding two key innovations to the cryptocurrency systems that came before: (a) the Ethereum Virtual Machine which executes smart contracts and its method for assigning cost to computation, and (b) the use of Patricia trees to enable compact proofs of any aspect of a blockchain’s state. And yet, inexperienced as well, because some of Ethereum’s design choices are so obviously terrible, such as the silent-but-violent call stack limit, or the ability of a payment recipient to recursively trigger the code which paid it.
None of this would be a problem if Ethereum was being treated as an experiment, worthy of exploration but with critical issues remaining to be resolved. The equivalent perhaps of bitcoin during its first couple of years, when its total market capitalization didn’t go beyond a few million dollars. Unfortunately, as a result of speculation and inflated expectations, Ethereum hasn’t been given the same opportunity to find its proverbial feet. Instead, at less than one year old, it’s carrying a billion dollars in market value. Ethereum is like a toddler being forced to cook dinner, or an economics freshman chairing the Federal Reserve. I believe it’s time to recognize that the immaturity problem of individual smart contracts also applies to Ethereum as a whole.
Ethereum’s way forward
While I’m yet to see strong use cases for smart contracts in private or permissioned blockchains, I think they probably do have a place in public chains with associated cryptocurrencies. That is, if you accept the basic premise of censorship-free financial systems, which help the financially excluded and ransomware authors in equal measure. Putting this debate aside, there is certainly technical merit in a cryptocurrency which supports arbitrary logic, of the sort that cannot be implemented on “first generation” blockchains like bitcoin. For now at least, Ethereum is the first and only convincing attempt to build such a system, with a ton of money and momentum behind it.
Nonetheless, as a developer ecosystem, Ethereum appears to be fundamentally broken. While The DAO is its most costly and high profile failure, many other contracts are suffering from similar problems. So how can Ethereum clean up its act?
- Send a clear message that, at least for the next two years, nobody should send any funds to a smart contract unless they are happy to lose them in the name of self-education.
- Fix some glaring issues with the Ethereum Virtual Machine (“EVM”), namely: (a) removing the call stack limit, (b) providing a way to send ether without triggering code, and (c) allowing contracts to be marked as “non-reentrant”, meaning that their functions cannot be called while they are already in the middle of something.
- Develop a new programming language for smart contracts, which uses a more restrictive method for expressing computation that is amenable to formal proofs of correctness. Decades of research have already been invested in this field, so there is much existing work to be leveraged. (This won’t require changes to the EVM itself, since the chosen language could still be compiled into regular “bytecode”.)
- Build up an official set of secure smart contracts and functions, which have been peer-reviewed to death and proven themselves reliable in many different situations. This is akin to the standard libraries that are available for many mature programming languages. (Though at this point it’s tempting to ask: why not just hard-code the functionality of these libraries into the EVM, and enjoy much better performance as a result? Answer: Because Ethereum was specifically designed to move away from blockchains with hard-coded feature sets. But still, it does make you wonder.)
The current option, of manually intervening in response to the failure of specific smart contracts, will not be viable on a larger scale if Ethereum is to maintain its identity as a trustless and decentralized computing platform. Indeed, some make a credible case that this single judgment-based act of governance has already destroyed Ethereum’s reputation. And we should note that The DAO’s terms and conditions explicitly state that nothing “may modify or add any additional obligations or guarantees beyond those set forth in The DAO’s code”. In other words, whoever drained The DAO was acting in accordance with its published terms, and is therefore presumably on the right side of the law.
We must also accept the possibility that, after several more years of good work, Ethereum might still prove too difficult for developers to work with safely. In that case, it will languish as a matchmaking service between anonymous scammers and their foolish marks. But that wouldn’t mean it was a waste of time – at the very least, Ethereum is a fascinating experiment, from which the blockchain community will learn a lot.
In the meantime, for users of private blockchains, I can only repeat what I’ve said before:
If your application doesn’t require smart contracts, then use a simpler blockchain architecture.
Whereas this advice was previously justified in terms of performance, it is now reinforced by the apparent difficulty of getting smart contracts right. And if you’re not sure whether your use case requires smart contracts, feel free to email us with some details, and we’ll be happy to let you know.
Please post any comments on LinkedIn.
Gemini Has Now Opened Doors to Crypto Investors in the UK
New-York based cryptocurrency exchange Gemini has officially launched in the UK. This comes after the UK’s Financial Conduct Authority (FCA) granted it an Electronic Money Institution (EMI) license.
The Winklevoss-led bitcoin and crypto trading platform is also one of the first businesses to receive FCA’s approval as a part of it’s Fifth Money Laundering Directive (5MLD) crypto-asset registration process.
Crypto Exchange Gemini Launches In The UK
The British government is pondering of imposing a second nationwide lockdown. The folks at Gemini saw this as a great opportunity to announce their launch in the UK, to ‘milk’ the ongoing and upcoming surge in bitcoin and crypto trading activities in the country.
Gemini is open for business in the UK🇬🇧
— Gemini (@Gemini) September 24, 2020
As per the official blog article, Gemini announced the rollout of its full suite of services for UK users. The New-York based bitcoin exchange has also added support for the state-backed fiat currency GBP. This Gemini said is to ‘provide a more local experience’ to its British users.
UK Launch Coming After Electronic Money Institution License Approval
As reported by CryptoPotato last month, Gemini became one of the first cryptocurrency trading platforms to receive the UK Financial Conduct Authority’s Electronic Money Institution (EMI) license. This approval gives it the official permission to offer bitcoin and crypto trading services to both individuals and institutions.
Gemini said that the launch in the UK after the receipt of the above license is an effort to work ‘proactively with regulators and asking for permission, rather than forgiveness’. The exchange added:
As a licensed and compliant platform, we abide by the high regulatory standards established to safeguard your money, securely store your crypto, protect your privacy, and keep bad actors off our platform. Ultimately, this fosters a better and safer experience for you and the larger crypto ecosystem as a whole.
Gemini CEO, Tyler Winklevoss quoted the exchange’s latest development as a significant milestone in the quest for global expansion. He added that operating the British market holds immense importance for Gemini:
The UK is a global center of financial innovation with a stringent and progressive regulatory regime. We’re proud to help usher the crypto revolution into this historic market and become a part of its rich tradition. We look forward to welcoming consumers and institutional customers to our platform.”
Waves vs Currents: How the Hashpower Market Can Complement Altcoins
Last month, Bitcoin’s difficulty and hashrate hit an all-time high. And while some experts argue increasing hashrate is a bullish price signal, others contend a strong correlation between the two has never existed.
Regardless, companies are capitalizing on the value placed on hash power, recognizing not only the varied usage hash power possesses beyond mining, but also the natural evolution of trading options for investors.
The Importance of Hash Power
Though analysts can’t agree on the relationship between hashrate and pricing, they can agree on the importance of hash power itself.
At the beginning of 2020, exchanges were expanding their product offerings and entering the world of derivatives. Recently, a number of start-ups entered the derivatives market as well – such as Global Hashpower Exchange, an exchange dedicated purely to hash power futures contracts.
“We see hash power as more than the ‘generator’ that powers data mining. It’s an essential key for a rapidly expanding array of ‘big data’ services, such as artificial intelligence, data analysis, and security protocols,” says Eno Chen, CEO of Global Hashpower Exchange.
But as the use of hash power grows, getting traders to practice trading it as a commodity will take time to adopt.
“I think all traders want options. Just as the stock market expanded into commodities and bonds, crypto traders are growing tired of simply buying, holding, and selling coins. Investors can decide if they want to invest in waves or currents,” says Chen. “Investing in hashpower futures is like catching a current that will likely carry you to your financial goals, while day trading coins is closer to surfing waves in pursuit of short-term financial wins. The strategies complement each other and both have a place in a balanced investment portfolio.”
Global Hashpower Exchange is currently giving new users a free 200 USDT deposit and 10 free trades with the promo code “Hashpower” on their site.
Trading Hash Power
GHPEX allows users to trade futures contracts where the underlying asset is a network’s hashrate. This could be used as a means of diversifying a cryptocurrency portfolio as the correlation between price and hashrate is not necessarily relevant.
Furthermore, the exchange would also allow users to trade with a leverage of up to 10x. Naturally, leveraged trading can increase your profits but it can also cause massive and quick loss of capital. It’s not recommended for people without sufficient market experience and you should never invest more than you can afford to lose.
The official website claims that the company is fully regulated by the FCA and CySec and that users’ funds are protected by industry-leading security protocols.
In terms of deposits, users can use BTC, ETH, and USDT. The same is true for withdrawals. The base currency and user balance are displayed in USDT. There’s a flat $1 trading fee per contract traded.
According to the FAQ section, GHPEX uses a combination of cold and hot wallet storage to safeguard the funds of investors.
LINK Marines Lock and Load as Price Falls to Six Week Low
Chainlink’s native token LINK has been one of the hottest crypto assets this year but that has not helped it escape this week’s big selloff.
Crypto asset markets have dumped $35 billion in terms of total capitalization since the weekend and the sell-off looks set to continue as Bitcoin and its brethren weaken.
A number of crypto assets are retreating from their all-time highs this year and investors are looking for entry points. Chainlink is among them as one of the year’s best performing crypto assets cools off quicker than some of its competitors.
LINK Marines Loading Up
LINK prices have collapsed to their lowest levels for almost two months in a fall back to $7.30 according to Tradingview.com.
There has been a minor recovery today as the token topped $8 again, but it is still massively down from its all-time high in mid-August. Back then the Chainlink token briefly touched $20 but it has been a downward slide ever since resulting in a 60% slump to current levels.
This price zone serves as solid support, however, there may be another dip to the 200 day moving average which lies around the $6.60 level.
Crypto investors have been eyeing the charts and are loading up on LINK which could drive prices back up in the short term. Trader and analyst going by the twitter handle ‘RNB (Crypto Warrior)’ (@CryptoWarrior01), has seen the same chart predicting a bounce back to $10 or $12.
— RNB (Crypto Warrior) (@CryptoWarrior01) September 23, 2020
The sentiment has been echoed by fellow trader ‘MacroLINK’ (@MacroCRG), who has also admitted to becoming a ‘LINK Marine’ and entering at these levels.
Picked up a long term bag of $LINK here.
I will hold this forever.
I am now a fully fledged Link Marine. pic.twitter.com/VlDx2zyeUN
— MacroLINK🚀 (@MacroCRG) September 23, 2020
Further downsides are expected though if markets continue to bleed as they have done for most of this week. Chainlink’s market capitalization is currently just over $3 billion which puts it ahead of Crypto.com but just below Binance Coin according to Coingecko.
Crypto Market Selloff Accelerates
LINK has not been the only token to suffer, however, it has been in a downtrend for around six weeks.
Bitcoin, which is largely the bellwether for the rest of the market, is holding crucial support just below $10,300 at the time of writing. Failure to hold here will see the asset tumble back into four figures pretty quickly.
Ethereum is also in pain, falling to its lowest level for three weeks and crucial support at $325. Many of the lower cap altcoins, especially the DeFi related ones have dumped 50% since their giddy peaks in recent weeks.
To get the daily price analysis, Follow us on TradingView
Martin has been writing on cyber security and infotech for two decades. He has previous forex trading experience and has been covering the blockchain and crypto industry since 2017.
Blockchain4 weeks ago
Market Wrap: Bitcoin’s Powell-Induced Price Swing; Ethereum Still High on Gas
Blockchain1 month ago
The US Post Office Files a Patent for a Blockchain-Based Voting System
Blockchain4 months ago
How to Identify the ‘Third Wave’ of Cannabis Investments
Blockchain2 months ago
Wealthfront Lures Millenials With Crypto Memes and Tactics
Blockchain2 months ago
Top Five Most Advanced Cryptocurrencies
Blockchain2 weeks ago
Blockchain Bites: Is DeFi an Inside Deal?
Blockchain4 months ago
5 Tips to Interest the Press in Your Cannabis Business
Blockchain3 months ago
Top 5 Most Effective Cannabis Marketing Strategies