CoinAlpha, founded in 2017, is a FinTech software engineering company specializing in trading software and services for digital assets, combining expertise in data engineering, machine learning, and blockchain engineering to create trading solutions that empower companies to take control of their token liquidity

CoinAlpha

coinalpha

Information is the foundation of good decision-making. Cryptocurrency innovates at the speed of light. New protocols are constantly coming to market, promising to solve some of mankind's greatest financial troubles. While their intentions might be good, the result is a cluttered, noisy environment that promotes FOMO & makes it nearly impossible to make sound decisions. In order to succeed in the wild, volatile, & often opaque world of cryptocurrency it is necessary to quiet the noise & hone in on real signals. The best way to do that is by building out your own Crypto ToolKit. Quick Notes on building a Crypto ToolKit: -) Do not use every single tool (unless you’re a crypto savant) -) Review each resource/tool individually (5–10 min per resource) -) Select only the ones that appeal most to your specific preferences As you might already be aware, the crypto-verse is highly fragmented in the sense that there are many different chains & protocols. Given that not all chains & protocols are interoperable (yet), all of the tools listed provided below are will be as general & multi-purpose as possible. Without further ado, Let's dive in: 📊 Market Data 📊 The starting point of almost every person’s crypto journey, Market Data providers are listing sites that aggregate all open financial digital asset data. All of the fundamental economic elements, Price, Volume, Circulating supply, Orderbooks, market dominance, historic data, & everything else. 1) Token Terminal - https://tokenterminal.com/ 2) Messari - https://messari.io/ 3) Crypto Slate - https://cryptoslate.com/coins/ 4) CoinGlass - https://www.coinglass.com/ Coin Market Cap -** 5) https://coinmarketcap.com/ - 6) Coin Gecko https://www.coingecko.com/ 7) Coin Metrics - https://coinmetrics.io/ 8) Coinlib - https://coinlib.io/ 9) Crypto Compare - https://www.cryptocompare.com/ 10) CoinCap - https://coincap.io/ - 11) CoinRanking https://coinranking.com/ 12) Coin360 — https://coin360.com/ — 13) Bitgur https://bitgur.com/ — 14) Nomics https://nomics.com/ - 15) CryptoWatch https://cryptowat.ch/ 16) BraveNewCoin — https://bravenewcoin.com/ 17) LiveCoinWatch — https://www.livecoinwatch.com/ 18) MultiCoinCharts - https://www.multicoincharts.com/home/ 19) Nansen - https://www.nansen.ai/ 20) CoinPaprika - https://coinpaprika.com/ 21) CoinAlpha - https://coinalpha.app/ 22) CoinScope - https://www.coinscope.co/ 23) DropsTabs - https://dropstab.com/ 24) CryptoView - https://www.cryptoview.com/ 25) CoinCarp - https://www.coincarp.com/ 26) Mytokencap - https://www.mytokencap.com/ 27) CoinCodex — https://coincodex.com/ — 28) CoinLobster https://coinlobster.com/ 💱 DEFI Dashboard & Aggregators💱 Decentralized finance is an incredibly broad term that includes a wide range of applications that vary based on functionality & intended purpose. While the majority of current DEFI activity happens across 4 blockchains (Ethereum, Binance Smart Chain, Polygon & Solana) there are so many up & coming alternative platforms such as Optimism & Arbitrum that have been garnering attention that for the sake of brevity I will only list the few products that I am personally familiar with. 1) Dapp Radar — https://dappradar.com/defi 2) DEFI Llama — https://defillama.com/ 3) DEFI Prime — https://defiprime.com/ 4) DEFI Pulse — https://www.defipulse.com/ 5) YieldWatch - https://www.yieldwatch.net/ 6) ZapperFI - https://zapper.xyz/ 7) Zerion - https://zerion.io/ 8) InstaDapp - https://instadapp.io/ 9) Frontier - https://www.frontier.xyz/ 10) Apebored - https://apeboard.finance/ 11) Debank - https://debank.com/ - 12) APYvision https://app.apy.vision/ - 13) Plasma Finance https://plasma.finance/ - 14) Farm Army https://farm.army/ - 15) DEFISaver https://defisaver.com/ - 16) Gnosis Safe https://gnosis-safe.io/ - 17) DefiYield https://defiyield.app/ 18) Coin98 - https://coin98.com/ 19) AstroTools - https://astrotools.io/ 20) MultiFarm - https://www.multifarm.fi/ 21) OctoFi - https://octo.fi/ 22) Parallel - https://parallel.fi/ 23) Exponential - https://exponential.fi/ 24) WalletDefi - https://walletdefi.app/ 25) DEFImarketCap - https://defimarketcap.io/ 26) QuantifyCrypto - https://quantifycrypto.com/ 📰 News 📰 Crypto is becoming all the more politicized as time goes on. An absurd amount of crypto/DEFI news sites pop up constantly & push their own agendas. The best way to source news (in any industry) is by having a few reliable individual outlets & cross-referencing information across them all. 1) CoinDesk - https://www.coindesk.com/ 2) Coin Telegraph - https://cointelegraph.com/ 3) Bitcoin Magazine - https://bitcoinmagazine.com/ 4) The Cryptonomist - https://en.cryptonomist.ch/ 5) Be In Crypto - https://beincrypto.com/ 6) CoinGape - https://coingape.com/ 7) CryptoSlate - https://cryptoslate.com/ 8) Crypto Briefing - https://cryptobriefing.com/ 9) CryptoDaily - https://cryptodaily.co.uk/ 10) Crypto Potato - https://cryptopotato.com/ 11) BraveNewCoin - https://bravenewcoin.com/ 12) Coin Journal - https://coinjournal.net/ 13) Coin Speaker - https://www.coinspeaker.com/ 14) CoinCu - https://news.coincu.com/ 15) Bitcoinist - https://bitcoinist.com/ 16) CryptoPanic - https://cryptopanic.com/ 17) Crypto News - https://cryptonews.com/ 18) U Today - https://u.today/ 19) CoinGraph - https://www.coingraph.news/ - 20) Decrypt https://decrypt.co/ - 21) Blockworks https://blockworks.co/ - 22) CryptoCapitalNews https://cryptocapitalnews.com/ — 23) Protos https://protos.com/ 👛 Wallets 👛 Wallets are the foundation for getting involved & staying in crypto. Wallets are exactly what they sound like, places to securely store/view your crypto asset holdings. Wallets typically come in 2 flavors, Chain-specific & Chain-agnostic. Chain-specific wallets are tied to a single blockchain platform (i.e ETH/BNB). These will only be able to store their native chain tokens, but allow the users to interact with on-chain assets/applications. Whereas chain-agnostic wallets might allow their users to store crypto assets from any blockchain, but that is the limit of their capabilities as they are usually single-purpose only (storage) 1) MetaMask - https://metamask.io/ 2) MEW - https://www.myetherwallet.com/ 3) Dynamic - https://www.dynamic.xyz/ 4) XDEFI - https://www.xdefi.io/ 5) Enkryptic - https://www.enkrypt.com/ 6) Argent - https://www.argent.xyz/ 7) Dopamine - https://dopamineapp.com/ 8) TrustWallet - https://trustwallet.com/ 9) Eidoo - https://eidoo.app/ 10) Dapppocket - https://www.dapppocket.io/ 11) Atomic Wallet - https://atomicwallet.io/ 12) Bread Wallet - https://brd.com/ 13) Guarda - https://guarda.com/ 14) Exodus - https://www.exodus.com/ 15) ZenGo - https://zengo.com/ 16) Coinomi - https://www.coinomi.com/en/ 17) Luno - https://www.luno.com/en-US 18) Ambire - https://www.ambire.com/ 19) Jaxx - https://jaxx.io/ 20) Edge - https://edge.app/ 21) Freewallet - https://freewallet.org/ 22) Coinbase Wallet - https://www.coinbase.com/wallet 23) Coin Wallet - https://coin.space/ 24) Ballet Wallet - https://www.ballet.com/coins/ 25) Unstoppable - https://unstoppable.money/ 26) Brave Wallet - https://brave.com/wallet/ 27) BitPay - https://bitpay.com/wallet/ 28) Crypto.com - https://crypto.com/us/defi-wallet 🔎 Explorers 🔍 Explorers are software tools that allow users to inspect the activity that has happened/is happening on-chain. Explorers are typically built-to-blockchain, meaning every chain needs its own explorer. Given the girth of data these tools access, explorers tend to be multi-purpose tools (i.e. data providers/ analytics dashboards/compliance). 1) Ethscan - https://etherscan.io/ 2) Bitquery - https://explorer.bitquery.io/ 3) Blockchair - https://blockchair.com/ 4) Tokenview - https://tokenview.io/ 5) Blockcypher - https://www.blockcypher.com/ 6) GetBlock - https://getblock.io/explorers/ 7) ViewBlock - https://viewblock.io/ - 8) BreadCrumbs https://www.breadcrumbs.app/ 9) Beaconchain - https://beaconcha.in/ 10) Blockstream - https://blockstream.info/ 11) Ethplorer - https://ethplorer.io/ 12) OXT - https://oxt.me/ 13) Xscan - https://xscan.io/ 14) Sochain - https://sochain.com/ 15) OkLink - https://www.oklink.com/en 16) Pingpub - https://ping.pub/ ⛓ On-Chain Data ⛓ On-chain data tools are closely related to explorers in the sense that they allow users to inspect the activity that has happened / is happening on-chain. The main difference between the On-chain Data tools & Explorers is the UI & granularity of data they provide.*The main difference between On-Chain data providers & traditional market data is the absence of information that is external to any blockchain. 1) Glassnode - https://glassnode.com/ 2) Dune Analytics - https://dune.com/home 3) IntoTheBlock - https://www.intotheblock.com/ - 4) Mempool https://mempool.space/ 5) Artemis - https://www.artemis.xyz/ - 6) Parsiq https://www.parsiq.net/ 🌉 Bridges 🌉 Within the context of cryptocurrency, a bridge is a software tool or protocol that allows otherwise non-compatible blockchains a method to transfer digital assets between one another. 1) MultiChain - https://multichain.org/ 2) CrossChain Bridge - https://www.crosschainbridge.org/ 3) Celer C Bridge - https://cbridge.celer.network/1/56/USDC 4) Synapse - https://synapseprotocol.com/ 5) Connext - https://bridge.connext.network/USDC-from-ethereum-to-binance 6) Relay - https://www.relaychain.com/ 7) Symbiosis - https://symbiosis.finance/ 8) Umbria - https://umbria.network/ 9) EverBridge - https://www.everrise.com/everbridge/ 10) Bungee - https://www.bungee.exchange/ 11) Portal Bridge - https://www.portalbridge.com/#/transfer 12) Nomad - https://www.nomad.xyz/ 13) Hop - https://hop.exchange/ 14) PolyBridge - https://bridge.poly.network/ 15) SolarBeam - https://app.solarbeam.io/bridge 16) Orbitchain - https://orbitchain.io/about 💹 DEXes 💹 Decentralized Exchanges are the new financial trading paradigm. Generally free from traditional regulatory scrutiny, DEXs are places to buy, sell, swap & provide liquidity for crypto assets. 1) UniSwap - https://uniswap.org/ 2) 1inch - https://app.1inch.io/ 3) DexTools - https://www.dextools.io/app/en 4) DexGuru - https://dex.guru/ 5) GeckoTerminal - https://www.geckoterminal.com/ 6) PancakeSwap - https://pancakeswap.finance/ 7) TraderJoe - https://traderjoexyz.com/avalanche 8) Arken - https://swap.arken.finance/ 9) Flooz - https://flooz.trade/trade 10) Balancer - https://balancer.fi/ 11) Bancor - https://home.bancor.network/ 12) Airswap - https://www.airswap.io/#/ - 13) Sushiswap https://www.sushi.com/ 14) Paraswap - https://www.paraswap.io/ 15) Jupiter - https://jup.ag/ 16) ThorChain - https://thorchain.org/ 17) WooFi - https://fi.woo.org/ 18) DYDX - https://trade.dydx.exchange/ - 19) Slingshot https://app.slingshot.finance/swap/ETH 20) Apex Exchange - https://www.apex.exchange/ 21) Osmosis - https://app.osmosis.zone/ 22) Curve - https://curve.fi/#/ethereum/swap 23) Tokenlon - https://tokenlon.im/instant 24) Swapz — https://www.swapz.app/ 📅 Calendars & Event Schedules 📅 Keeping up with the Kardashians is much easier than keeping up with your favorite crypto protocol; the question then becomes HOW do you plan to manage the onslaught on events? While there is no easy answer, using a Crypto Calander will definitely help: 1) CoinMarketCal - https://coinmarketcal.com/en/ 2) CoinDar - https://coindar.org/ 3) CoinsCalendar - https://coinscalendar.com/ 4) CryptoTotem - https://cryptototem.com/ico-calendar/ 5) CoinCarp events - https://www.coincarp.com/events/ 6) VestLabs - https://vestlab.io/calendar 🪂 Airdrops 🪂 The most popular tool for distribution in the entire industry, airdrops are incentives that are offered/provided at the earlier stages of a project’s development to help bootstrap it’s alpha community members. 1) Earnifi - https://earni.fi/ 2) airdropsio - https://airdrops.io/ 3) AirDropAlert - https://airdropalert.com/ 4) AirdropsLive - https://airdrops.live/ 5) AirdropBob - https://www.airdropbob.com/ 6) AirDropAddict - https://airdropaddict.com/ 7) CoinAirDrops - https://coinairdrops.com/ 8) ICOdrops - https://icodrops.com/ 💸 Grants 💸 Grants are a necessary component to helping startups & innovators get their ideas off the ground. In the world of crypto & blockchain grants are usually offered & deployed on a chain/case-specific basis. In order to be properly up to date on grant opportunities it is best to be actively involved in individual projects and/or blockchains. 1) Blockchain Grants - https://www.blockchaingrants.org/ 2) GitCoin - https://gitcoin.co/grants/ 3) Consensys - https://consensys.net/grants/ — 4) Concoridum https://concordium.com/grants/ 5) Web3 grants - https://web3grants.net/ 6) Web3Foundation - https://web3.foundation/grants/ 7) Ramp Rate - https://ramprate.com/blockchain-grant-opportunities/ - 8) Unigrants https://www.unigrants.org/ 9) Aave grants - https://aavegrants.org/ 10) Near grants - https://near.org/ecosystem/get-funding/ 11) Eth Foundation - https://esp.ethereum.foundation/ 12) Zcash grants - https://grants.zfnd.org/ 13) Alchemy Dev grants - https://www.alchemy.com/developer-grant-program — 14) dydx grants https://www.dydxgrants.com/ 15) Solana grants — https://solana.org/grants 16) Gate grants - https://www.gate.io/grants 17) Cryptoneur - https://www.cryptoneur.xyz/en/web3-grants 🛡 Audits 🛡 Audits are used to assess the quality/security of a protocol. When considering a protocol to use, it is nearly impossible to understand all of the associated risk factors, even for professionals. It is crucial that every serious project employs some form of audit for every individual piece of software. 1) Certik - https://www.certik.com/ 2) Consensys Dilligence - https://consensys.net/diligence/ 3) Hacken - https://hacken.io/services/smart-contract-security-audit/ 4) Open Zepplin - https://www.openzeppelin.com/security-audits 5) Trail of Bits - https://www.trailofbits.com/ 6) Slowmist - https://www.slowmist.com/ 7) Solidified - https://solidified.io/ 8) Chain Security - https://chainsecurity.com/smart-contract-audit-reports/ 9) PeckShield - https://peckshield.com/#home 10) Halborn - https://halborn.com/ 11) Quantstamp - https://quantstamp.com/ 12) Solidity Finance - https://solidity.finance/ - 13) Immune Bytes https://www.immunebytes.com/ 14) NumenCyber - https://www.numencyber.com/ 🌊😎 Cool & Honorable Mentions 😎🌊 There are always exotic instruments & services being built to help make sense of the wild world of crypto; some of these are difficult to classify but still deserve attention for serving their own unique & useful purpose(s). 1) Fiat Leak - https://fiatleak.com/ 2) Everest - https://everest.link/ 3) Revoke.cash - https://revoke.cash/ 4) CryptoQuant - https://cryptoquant.com/asset/btc/summary - 5) CryptoFees https://cryptofees.info/ - 6) Hashrate Index https://data.hashrateindex.com/asic-index-data — 7) LunarCrush https://lunarcrush.com/home — 8) Santiment https://santiment.net/ 9) Gas Fee Calculator - https://www.cryptoneur.xyz/en/gas-fees-calculator This list is by no means exhaustive, there are thousands of other tools/resources out there. Odds are, you do not even need 1/10 of those on this list; so my recommendation is don’t waste time wishing for better tools — learn how to masterfully use a few key ones provided above. If you went through the entire list, you might have noticed that there are no CEFI (centralized financial) tools on this list. This was done on purpose, given the madness that transpired with centralized exchanges/service providers throughout 2022. If you would like me to add any specific resource that might be beneficial to others, just drop a comment below or send me a DM on Twitter. Otherwise; I hope you find these tools helpful in building your knowledge & financial freedom. Thank you so much for reading! 🥂🚀 See you in the next Bull Market 🚀🥂 Also published here.

200+ Essential Crypto & DEFI Tools for 2023

Welcome to the Sherman Group Daily Briefing. In each briefing, we let you know the top 3 pieces of news you should know about in the and industry along with today’s top reads. cryptocurrency blockchain Sorry, I’ve been gone for so long. A bunch of updates. You will be hearing from me daily again. I am launching a consulting firm called , we help governmental agencies, Fortune 500 companies and institutional investors understand the blockchain and cryptocurrency space. Our first client was the State of Ohio’s Treasurer Office where we helped implement the first cryptocurrency tax payment portal. You can read about it . I will have some updates about Grasshopper Capital in the next couple of weeks. Stay tuned. The Sherman Group here What’s Happening Today? Bitmain closing Israeli development center. ( ) Globes Bitmain is closing its Israel office and laying off all 23 of the employees who work there. What’s the Story? Bitmain has been the leader in the cryptocurrency mining space for some time now. For the past couple of years, they have literally been printing money, but a combination of bad decisions (eg. supporting Bitcoin Cash) and a significant decline in cryptocurrency prices has affected their business. I wouldn’t look too much into the fact that they are shutting down their Israeli office, but it does show that even the mightiest cryptocurrency companies sometimes bleed. It’s not 2017 anymore. Why It’s Important? SEC Fines Crypto Fund $50K and Issues Cease-and-Desist ( ) Coindesk Coinalpha, a cryptocurrency hedge fund, was fined $50,000 and ordered to shut down by the SEC. What’s the Story? I’ve never heard of this fund and the fund being fined isn’t that important, but what is important is the increase in civil actions being pursued by governmental agencies specifically the SEC. In September, the SEC brought a civil action against cryptocurrency fund, CAM, as well as an action against an unregistered broker-dealer named TokenLot. I’ve reguarly talked about the idea that if something looks like and acts like a security, it’s probably a security and the SEC has jurisdiction. You can’t just say, I am investing in or creating a cryptocurrency and, we don’t have to follow security laws because we are magically exempt. It doesn’t work like that. I’m not a lawyer though, so if you don’t believe me contact one and ask them. Why It’s Important? Layoffs Become the Latest Thing in Cryptocurrency ( ) Wall Street Journal Consensys and other cryptocurrency companies are laying off employees left and right. What’s the Story? This story is similar to the Bitmain story. Recently, Consensys laid off 13% of its staff while other firms such as Spankchain and Steemit have also reduced headcount. It’s obvious to say that in a recession people get fired while in a bull market people get hired, but I want to go deeper than that. Many firms hired too many people for roles that just weren’t necessary. Consensys employs over a 1,000 people. That is a mind-boggling number. Consensys has offices in 28 cities. Their hiring practices are the definition of profligate spending. I have deep respect for Lubin and think he is a visionary, but before firms go on hiring sprees, they need revenue from a product that is selling. I don’t see many firms making money besides exchanges and maybe mining firms. Why It’s Important? Top Links The Rise of Decentralized Finance. ( ) Trustnode The Price Crash & The Impact On Miners. ( ) BitMex Bitcoin & Ethereum: Prices are Down More than the Fundamentals. ( ) Chris Bursinke This newsletter was written by @amlewis4 and edited by @MichamJake .

The Sherman Group Daily Briefing: December 10, 2018

Market Cap: $109,672,007,61724h Vol: $16,543,133,132BTC Dominance: 54.8% From Monday, December 3rd when the evaluation of the cryptocurrency market capitalization was around $135 billion, the market has depreciated in evaluation by approximately 25,4 billion dollars measured to the current levels. The evaluation has gone even lower and was $104B on yesterday’s low. Looking at the global chart you can see that the evaluation is in a clear downtrend has been established and the evaluation is again back to its resistance line. As the evaluation looks like is going to make a lower high a lower low would be expected from here. Zooming out further on the global chart we can see that the evaluation previously broke out from a symmetrical triangle from the downside on December 3rd when this current downtrend has begun. After the evaluation decreased by over 25 billion dollars at one go, a lower leg has started developing which is what was happening every step of the way down, over and over again. Inversely the evaluation of the Bitcoin’s market dominance has been steadily increasing and since the 3rd of December when it was 53.67% it has increased by 1.13% as its currently sitting around 54.8%. Zooming out further onto the Bitcoin’s percentage of total market capitalization you can see that this increase meant a breakout from the triangle on the upside. Now that the evaluation has ended its consolidation and is in an upward trajectory I would expect it to go up to 68% before the bear market ends or potentially even higher than that. Bitcoin’s market dominance evaluation serves as a sentiment indicator as in times of confidence, people tend to risk more and they diversify more over the crypto market with altcoins, but in times of fear uncertainty and doubt, people sell their alts for Bitcoin and ultimately sell their Bitcoin for cash in an attempt to preserve their capital. News From the start of the week, major news headlines have come out with many of them adding to the bearish sentiment and could impact or already have impacted the market negatively. The headlines significance is measured by its impact on the market so among those who are of utmost significance are regarding regulation and formal frameworks for the crypto industry. The most notable news about the overall regulative future outlook for the crypto market and the industry, in general, can be hinted by what has recently been said at the G20 summit in Argentina. Cryptocurrencies have been addressed by the international government and central bank representatives in the declaration on sustainable development for the global economy titled “Building Consensus for Fair and Sustainable Development” among other important issues. The summary of what has been stated there is that more regulation is coming and with it the taxation of the entire space and the overview of the transactional frameworks and exchanges, in the attempt to prevent money laundering and tax avoidance. “We will regulate crypto-assets for anti-money laundering and countering the financing of terrorism in line with FATF standards and we will consider other responses as needed.” On the other hand, G20 counties will develop an international taxation system which views the whole cryptocurrency market as one big IT company, making it possible to tax international transactions and other cross-border payments. As reported by the Japanese news outlet Jiji, under current laws that is impossible so the declaration further states: “We will seek solutions for the international taxation issue accompanying the digitization of the economy and will continue to collaborate”. These measures should be implemented by 2020 but the process has already started since members of the G20 counties are to submit their reports on the crypto taxation system during the next G20 summit scheduled for 2019 in Osaka, Japan. The second by its significance on the market is the adoption and the most important headline from this week from that category would be news regarding SEC delaying the decision for a Bitcoin ETF for late February. It is considered that an ETF would bring some institutional money into the space and help bring some legitimacy to the cryptocurrency trading, thus bringing new investors. This new inflow of capital would potentially spark the end of the bear market which is why this would be considered as a significant event, however, the Securities and Exchange Commission has however postponed the decision and the new deadline is set for 27. February next year. This was done in order for the commission to buy some time and review the rule change proposals to approve the request for an ETF by investment firm VanEck and blockchain company SolidX “The Commission finds it appropriate to designate a longer period within which to issue an order approving or disapproving the proposed rule change so that it has sufficient time to consider this proposed rule change.” This means that the adoption of the cryptocurrencies among trader at least would have to wait and the new inflow of capital isn’t going to be injected any time soon. The other headline regarding the SEC is the cease and desist order they had fined to a cryptocurrency digital asset fund CoinAlpha Advisors LLC for violating the law that “prohibits the sale of securities through interstate commerce or the mails unless a registration statement is in effect.” While we are on lawsuits, the “hash wars” have escalated with a lawsuit from a Florida-based United American Corp. (UnitedCorp) against Bitmain, Bitcoin.com, Roger Ver, and the cryptocurrency exchange Kraken for they have “planned a scheme to take control of the Bitcoin Cash (BCH) network.” “UnitedCorp believes that the defendants colluded to effectively hijack the Bitcoin Cash network after the November 15, 2018 scheduled software update with the intent of centralizing the network — all in violation of the accepted standards and protocols associated with Bitcoin since its inception.” For those who maybe don’t know, this situation escalated after Bitcoin Cash was scheduled for a hard fork which divided into two chains Bitcoin ABC and Bitcoin SV, so the war between two sides for hash power took place in order to take control to be established as the main chain. The situation in the crypto industry resembles the situation with the current state of the cryptocurrency prices — crash. Both miners and companies around blockchain tech are starting to fell the pressure of these low prices and are starting to cut off some of the unnecessary expenses and some quitting altogether. Among those who are quitting altogether are miners. Many news media outlets have reported that miners who are outcompeted and cannot keep up the with the current cost to profit ratios are selling their equipment as the prices of cryptos have fallen below the profitable benchmark for some. Meanwhile, some of the large names from the space are starting to lay off their excess staff like ConsenSys who confirmed 13% layoffs as reported by Coindesk: “Excited as we are about ConsenSys 2.0, our first step in this direction has been a difficult one: we are streamlining several parts of the business including ConsenSys Solutions, spokes, and hub services, leading to a 13% reduction of mesh members.” On the other hand, the blockchain based social media platform Steemit is laying off even 70% of their current staff. Steemit CEO and founder Ned Scott said: “While we were building out our team over the last many months we have been relying on projections of basically a higher bottom for the market and since that’s no longer there, we’ve been forced to lay off more than 70 percent of our organization and begin a restructuring.” Conclusion All of these headlines paint a grim picture for the cryptocurrency market. Tracking the media and analyzing the market sentiment in that way could serve as a good indicator of where we are in the market cycle stages. According to current news analysis, we are currently at the start of the capitulation stage We were in denial until around $6500 for the price of Bitcoin and since the price crashed down by 50% there isn’t any doubt that the market is heading for a further decline with the despair stage not even in sight. For those who are prepared and can objectively look at the market, this serves as a good opportunity to make some profits while the market participants are acting on fear-based decision making.

Cryptocurrency Market Overview [December 2018]

n.exchange , our weekly sponsor, is the easiest way to exchange cryptocurrency, for individuals and companies alike. Exchange or purchase cryptocurrency with credit card now . ARTIFICIAL INTELLIGENCE by . Data in the age of AI has been described in any number of ways: the new gold,the new oil, the new currency and even . History, Waves and Winters in AI dudeperf3ct the new bacon by Machine Box CEO . I decided to make it a two-class problem; given some input, the market either goes up or down. And I limited to the Dow Jones Industrial Average. I spent 20 minutes trying to predict the stock market with AI — these are my results Aaron Edell the market BITCOIN DETAILS by Hodlbot Founder . These days, Bitcoin ETFs are the talk of the town. The market is in dire need of a rally, and investors believe institutional money flowing in from ETFs will do just that. An In-Depth Overview of Bitcoin ETFs Anthony Xie by Writer . This story is about how I managed to get free Bitcoin online, and while I can’t claim there was no effort involved, I can say it didn’t cost me any money. How I Got Over $11,000 in Free Bitcoin Mina Down BLOCKCHAIN by CS Grad . An Simple Guide to Understand Blockchain with a Real World Analogy. Beginner’s Guide to Blockchain — Explaining it to a 5 Year Old Sidharth Malhotra by Writer . I wrote a book on sharing, the sharing economy, but within a few weeks of the release of It’s a Shareable Life, I felt like I had to abandon everything I’d been working for. The sharing economy had changed. The Future of Blockchain — Bridging the Sharing Economy — a TEDx Talk Chelsea Rustrum BOARD GAMES by Software Engineer . I recently decided I was going to take the rules of the board game Forbidden Island and write them up as code. I guess that sounds like a weird thing to just decide to do, doesn’t it? 9 fascinating things I learned while coding up the rules of a board game Graham Lea CODE BETTER by Back-End Developer . The Ultimate Course and Book list to be an expert in Mathematics and Programming. Be a Better Programmer with these 45 Mathematics Courses Dibakar Sutra Dhar by . There are so many best practices and advanced patterns — the problem is keeping track of them and keeping them in mind as you develop new components. Checklist for Writing Highly Reusable Components in React and Vue Michael Thiessen by Hecate App Founder . The code review, usually performed using GitHub pull requests or the like, is now the highest leverage point for improving an engineering team’s output. Code Review Review is the Manager’s Job John Barton by Stream Developer Evangelism . Docker and Kubernetes are a powerhouse that makes it infinitely easier to develop fast, immutable applications capable of running on multiple operating systems, without all the hassle of handling all the requirements of package management. Containerizing a Node.js API & Using Docker with Kubernetes and Minikube Nick Parsons by Full Stack Developer . Benchmarking read performance of PostgreSQL and MongoDB on same data sets. PostgreSQL vs MongoDB v2 Vladimir Kovpak by Kainos Software Engineer . I’ve been working as an apprentice developer for a year now, and I thought it time to share my experience with any people thinking about joining or who have recently joined the industry. Surviving And Thriving In Your First Year As a Junior Developer Peter Lappin CRYPTO by , Research at Bitwise Invest. This piece provides an overview of the opportunities to generate investment yield within the cryptocurrency ecosystem. Cryptocurrency Yield Opportunities Phil Glazer by Samsa.ai Lead Analyst . The crypto markets are currently f*cked. Between the consistent manipulation they face, as well as specific issues per individual major exchanges like Coinbase Pro, Binance, and Bittrex, there is a lot to be concerned about when making even the simplest of token swaps and transfers. Unf*ck the Crypto Markets Brian Quinlivan by Data Solution Architect . Because the actual rate of adoption couldn’t possibly keep up with the high valuation expectation being set by speculators (because the value was rising too fast and the use cases too sparse), many of these speculators soon became mass _sellers_in the market. No one asset or organization caused this crash, it was simply the inevitable flow of the market out. Why is the Cryptocurrency Market Crashing? Another Long Term Perspective Brian Schuster DAPPS by CoinAlpha Co-Founder . Learning Solidity and writing a smart contract is relatively easy, but we’ve found that the harder technical challenge is designing a DApp backend infrastructure that is secure, scalable, and snappy. DApp Infrastructure Design (Part I): Reliable Ethereum Event Tracking with Kubernetes, Docker, and Parity Carlo Las Marias DESIGN by Atomico Venture Capitalist . Over the past eighteen months, I have begun to notice a trend across a number of startup teams, taking the design process and applying new computational techniques and algorithmic developments. Why disrupting design will accelerate humanity’s progress. Ben Blume ETH by TowardsBlockchain Founder . An Ultimate, In-depth Explanation of What EVM is and How EVM Works. Getting Deep Into EVM: How Ethereum Works Backstage vasa ESPORTS by , Partnerships at Visa. I strongly believe that within the next decade, millions of people across the world will earn a living from jobs related to video games and esports making it one of the fastest growing new industries. A Case for Interscholastic Esports Cuy Sheffield by Hooked Author . Communication technology in particular has given rise to a long history of companies that have provided better ways of delivering what I call, “rewards of the tribe.” Design for Rewards of the Tribe Nir Eyal GOOGLE CHROME EXTENSIONS by . It turns out Chrome extension development is almost like real web development, but with a weird dash of quasi embedded development mixed in. Creating a Chrome extension in 2018: The good, the bad and the meh Tim Nolet 👨🏻‍🚀 MARKETING by . Being human and vulnerable, on the other hand, is invitational and helps people feel like they can contribute to the direction in which you want things to go. “There’s nothing more powerful than saying to someone, ‘I don’t know the answer, but let’s work together to find it.’” Slack’s Kelly Watkins on the Importance of Setting Team Tone Early + More FirstMark by Designer & Consultant . Let’s be honest, converting visitors into customers isn’t easy, especially if you don’t have the expertise to be able to target them properly. 5 Free Tools to Make Your SaaS Landing Page Convert More Pedro Cortés OPEN SOURCE by , a cadet who codes. Generally people have a mindset that they need to be very expert in every (or any one) domain to start open source contributions. This is WRONG! Even if you are a beginner and you have a basic knowledge of Git and GitHub, you can start contributing. KickOff To Open Source! Madhav Bahl by Software Engineer . Even though we all agree about the importance of good documentation, there seems to be a widespread failure on our part to act on this belief and pay attention to how we document our software. Why does this happen? Need for better documentation Vaidik Kapoor PRODUCT MANAGER TIPS by Product Development Nut . The optimistic change-agent believes there is always a way forward: a communication issue to unravel, low hanging fruit to tackle, and more opportunities to establish psychological safety. But it also gets people (me included) into trouble. The Patient Change Agent John Cutler by Kapwing Founder . With training from coaches, role models, and senior PMs at Google, we learned what skills you need to develop to become a product leader. The Hard Skills of a Product Manager Julia Enthoven STARTUP LIFE by Writer . Don’t Look for a Big Idea, Focus on Identifying a Big Problem. What We’ve Learned in The First 30 Days of Startupbootcamp Michael Thompson TECH GIANTS by . How Alibaba are researching using the hardware features of ARM MMU to enable God Mode in Android 8 terminals Entering God Mode — The Kernel Space Mirroring Attack Alibaba Tech by . With what we’ve seen in the last two years, Google giving hints and tools for how to architecture an app, many of us were curious about the code. Just give me a sharp knife Google! * Danny Preussler TOKENOMICS by Invector Labs Managing Partner . The current generation of security tokens platforms is focused on two main areas: Toke Issuance & Security Token Exchanges. Let’s keep things in perspective, the entire security token space is about one year old and, regardless of how fast its evolving, remains very immature technologically. The Security Token 2.0 Stack Jesus Rodriguez Until next time, don’t take the realities of the world for granted. Kind Regards, David Smooke P.S. n.exchange , our weekly sponsor, is the easiest way to exchange cryptocurrency, for individuals and companies alike. Exchange or purchase cryptocurrency with credit card now.

Stories That Matter in Tech This Week

Learning Solidity and writing a smart contract is relatively easy, but we’ve found that the harder technical challenge is designing a DApp backend infrastructure that is secure, scalable, and snappy. Unlike traditional apps, DApps rely on the inherently probabilistic nature of blockchain state and utilize Ethereum components that are relatively new and under active development. This is Part I of a series of articles about the architectural patterns and practices we’ve learned that might benefit other DApp developers. Among the earliest lessons for anyone developing DApps on Ethereum is that logging events in smart contracts is an efficient way to report state changes and keep track of actions performed. Since events are emitted on the blockchain and can be replayed, while at the same time are technically not being stored in expensive blockchain state (i.e. memory or storage), they are a cost effective workaround for “storing” blockchain data. Events are also emitted real-time, allowing for real-time discovery and reporting of actions. Events sound great! Everyone should use events! Hold on, not so fast… Another early, and potentially painful, lesson for DApp developers is that event watching is unreliable: . If you need real-time data, but event discovery is delayed or events are missed altogether, this could result in a poor user experience or complete DApp failure. an event is only useful if your DApp detects it when needed Our solution: DApp developers who need reliable event tracking should consider adding Kubernetes/Docker to their toolkit. While these technologies do come with a bit of a learning curve, they neatly solve very specific problems in the current Ethereum technology ecosystem, mainly arising from reliability. Problems with current Ethereum infrastructure technology CoinAlpha Node Monitor At , we have been running a lot of experiments and research on Ethereum infrastructure and reliability to support our product. We have been using different cloud providers such as AWS, Google Cloud, and Digital Ocean to host nodes in addition to running our own local nodes. We have set up node monitors that allow us to track node performance and reliability, as the sample screen shot shows. CoinAlpha Since our projects require as close to real-time event tracking as possible, we have had to come up with solutions to address the current issues with Ethereum infrastructure: : For a number of reasons, Ethereum nodes periodically fail; they either stop syncing or fall behind, failing to have the latest blockchain information. The main cause for this is a , a kiss of death for any node. Drops in peer count can occur at any time, usually because a node gets stuck on a “bad” block that has been reorganized or ends up on a sidechain. Ethereum nodes work like the popular kids’ table; if your node ends up on a bad block, your node gets blacklisted or tainted, and all peers will try to drop it and prevent it from reconnecting. Ethereum nodes continually drop peers drop in peer count : A few months ago, released the capability for web sockets connectivity to support event tracking. This provides the ability for developers to track events without having to run their own nodes. While this was a substantial improvement over , it is still not a perfect solution. Infura’s web sockets are not able to maintain a constant connection and will drop connections every few minutes. Anyone who used the first versions of the , which used Infura to build and maintain a database of Augur-related events, probably noticed this effect. Infura websockets are unreliable Infura not supporting events at all Augur desktop client : Nodes regularly fall behind in syncing, by a few blocks. One main reason for this is hard drive read/write speed. Paying up for high speed SSD drives is a possible mitigant, but with the current Ethereum mainnet database exceed ing100GB, cloud hosting bills begin to snowball pretty quickly. In addition, this still doesn’t address the drop in peer-dropping problem. If your node falls behind and then does a syncing catch-up, we have found that live events may be missed. Live event watching using **watch()** can miss events Solution: Redundancy and Monitoring A fault-tolerant Ethereum event watching system is one that can detect failures, conduct triage, and continue operating as if nothing happened. Here’s how we design ours: : We run multiple Ethereum nodes, each with attached event trackers, to provide redundancy in the event of single or multiple node failures/delays. Node redundancy : Since live event tracking is unreliable, we cycle our event watchers to replay events, and stagger the replay timing between nodes. For added efficiency, we daisy-chain replays; we note the current block number at the time of each replay, so that the subsequent replay will only replay from that previous current block number. Event replays : Our event watchers report events to a centralized event aggregator. Our event aggregator keeps track of events it has already seen, and dispatches newly discovered and unique events to the different services we have that need to handle that event. Event aggregator The result is we have an architecture that looks like the following, with additional discussion of components below: Ethereum event watcher architecture with Kubernetes and Docker And just some of the cool things we like about Kubernetes. I understand there are many ways you can address the problems I’ve raised. If you have any comments, questions, or suggestions, you can contact our team on our or . Below are some explanations and discussion on some of our architecture choices. CryptoBaskets telegram group send us an email Why Dockerize? For our application, the benefit of using docker is that we are able to add on additional services that need access to the blockchain simply by launching new containers that can link to our parity instances. Each container runs independently, so changes, additions, and upgrades can all be completed without disrupting any of the other existing running containers/services. In the example above, we only have three containers connecting to the parity data: (1) the node monitor, (2) an event watcher for App 1, and (3) an event watcher for App 2. But we can easily add more containers, as and when our needs change. Why Kubernetes? Managing multiple node clusters (Ethereum clients and their connected services) can get pretty complicated and messy quickly. Not only are there multiple services that are linked and dependent on each other, updating and maintaining configurations as well as managing secrets (such as API keys) requires coordination and creates potential security vulnerabilities. In addition, monitoring servers and services for failures and restarting failed containers can get challenging in increasingly larger systems. That’s where Kubernetes comes in; it handles all of these issues. Below are some of the features that we find particularly useful: : Kubernetes is great for redundancy since it has built in scalability. You can automatically replicate node clusters (Ethereum clients and their attached services) by default, or through a single command line instruction. No need to configure each cluster separately. Replicas / scaling : You can simply add on new services or trackers that need access to your Ethereum node by adding containers to your Kubernetes deployment or stateful set. Adding on new services : Docker containers are ephemeral in nature. For syncing an Ethereum node, you don’t really want to sync a 100GB+ database every time your node fails and you have to restart. Kubernetes allows you to create Persistent Volumes, which is a segregated data store that maintains its data and state. If your Ethereum client is restarted, it will re-connect to the Persistent Volume and resume from where it last left off. Persistent Volumes with Stateful Sets : Using Kubernetes secrets are a neat way for storing API keys and any other sensitive data. The sensitive data is only exposed upon secret creation; once a secret it created, it is encrypted. The secrets can then be mounted as as a volume for any container that needs access to it; the original, unencrypted data does not have to be re-shared. Security : By clustering services together and providing each access to a shared volume (such as the Persistent Volume), services that need a connection to parity can access it via IPC ( ) through the cluster’s file system. This creates additional security by helping to prevent unauthorized access to the Ethereum client. By default, most developers will connect to web3 providers using an RPC ( ) http connection over the internet_._ Unlike a connection via IPC, an RPC connection is potentially open to the general public and internet, creating the risk of unauthorized users discovering and connecting to your RPC web3 provider and overloading your client. Worst case, someone connecting via RPC web3 from the internet would be able to send transactions from any account that may have inadvertently been unlocked. IPC connections for added security and access control inter-process communication remote procedure call web3.httpProvider() : Kubernetes allows you to create monitors that restart or take pods out of service that have failed or are not yet ready. For example, you can use a readiness probe to prevent an Ethereum client from accepting any incoming connections if it has not yet been fully synced. Liveness and readiness probes : When deploying updates to live apps, kubernetes neatly creates new before destroying the old, existing pods. While the new pods are being created and prepared (awaiting the probe), existing pods remain in service. Only once the updated pods are ready and put into service, will the old pods be destroyed. Live, rolling updates / no down-time pods readiness : Kubernetes allows for the setup on an nginx ingress controller to direct traffic to different services on the cluster, which are routed by the URL address used. In your domain manager, you simply direct all subdomains to your ingress address, so you don’t have to manage each separately in case your servers’ IP addresses change. The nginx ingress controllers also manage https routing and TLS certificates. In the DApp ecosystem, this can also be applied to creating web3 providers for front-end applications. By default, Ethereum clients provide only insecure http connections. Nginx ingress controllers Parity vs. Geth Despite the company’s previous missteps ( , ), the one thing Parity has going for it is they have created one reliable Ethereum client (ok…let’s also ignore the for now). While most developers start out using the Go implementation of Ethereum “ ”, a quick google/stack exchange search will reveal a lot of frustration and problems for syncing Geth. We’ve found that in practice, Geth nodes take longer to sync and fall behind more often than Parity nodes (which you can even see in our node monitor dashboard screenshot above). On the other hand, we have found that Parity nodes will sync from scratch and are available for use within a few hours to a day. multi-sig hack library hack consensus vulnerability Geth Being relatively new technologies, Ethereum clients like Parity and Geth are constantly being updated and improved, which is why we maintain both types of nodes. Conclusion Decentralized applications have a bright future, but given the nascency of the technology stack for them, substantial back-end work is necessary to make them feel as responsive and reliable as centralized web and mobile applications. Luckily, we’ve found that a careful, intentional approach to architectural design makes this feasible, and we’ll publish posts about other important aspects such as security in the future.

DApp Infastructure Design (Part I)

Hello! In this series of articles, I would like to show how applications can be created using Flutter. I use this technology at work, as well as my own projects on an ongoing basis since 2018. I have several Open Source solutions (popular and not so popular) that will be applied in this application (not for the sake of a tick, but as a solution to emerging problems). In the process of working on this application, I will touch on almost all aspects of development with Flutter, except explicit interaction with the native part (when you have to write the native code yourself), but if you have a desire to see this, then please comment. And most importantly, I already have the top-level idea of ​​the application in my head, and the code for this article and the next one has already been written, but if you have ideas that could be implemented in this application within the corridor of the original ideas - please share them in the comments. law Application Idea Initially, I did not know what this application would be about when I had the idea of writing these articles. All I wanted was to show the whole process from start to finish, and also, why hide it? - show the use of their Open Source solutions on such a semi-real project, in order to be able to refer to it, and not just to the examples in these packages. Actually, the idea came up quite recently I found a good free API with exchange information (stocks, quotes, etc.), which has both a large amount of data and methods for receiving real-time quote changes (via web-socket). There were thoughts to make something like a catalog of books - but it's too simple, and there were no other thoughts. Based on such a subject area, I started looking for some interesting UI layout, and found : this As a basis, I will take the colors, screen layout, and style of the charts from this layout. Screens, as I think so far, there will be two: The first is a list of all the positions that are on the exchange (right now, having written these lines, I thought it would be nice to do a search on it, because, looking ahead, there will be about 28,000 of these positions). This piece of design will serve as the basis: The only thing is that I quickly looked for some API to get index pictures, as they are drawn here for SPOT and MSFT, so there will be no pictures in my implementation. But if you know something that will allow you to solve this problem without resorting to manual image search, please share it. The second screen is a transition to the page of the position itself. It will be the most interesting - I planing to implement a chart of position quotes, a display of the current price, and a small game element - two buttons / (as in binary options, but without real money, cheating and only for the pleasure and interest). You will get such a mini-game application where you can not only watch quotes, but also "play" - I will enter a win counter and something related to it (I have not worked out this aspect in detail yet - write ideas). Up Down Implementation Well, I described the idea, it's time to get down to business. I will not write a detailed manual on how to deploy a new Flutter project, so we immediately start writing code. Based on all of the above, I can describe the structure of the project as follows: /root
  /service
    /routing
    /di
    /...
  /domain
    /main
      /dto
      /model
      /logic
      /ui
    /position
      /dto
      /model
      /logic
      /ui We'll start by implementing the service layer: DI Here, a developer can come to the aid of a large number of different packages that solve this problem - with or without code generation, with a large number of boilerplates and not, but it seems to me that this is a rather trivial task, and it is very easy to solve it yourself. So let's do it! All logic fits in two files - the container itself, and the logic for adding dependencies to it: import 'package:flutter/cupertino.dart';

class Di {
  static final Map<String, dynamic> _dependencies = <String, dynamic>{};
  static final Map<String, ValueGetter<dynamic>> _builders = <String, ValueGetter<dynamic>>{};

  static String _generateDiCode<T>([String name = '']) {
    return '$T$name';
  }

  static void reg<T>(ValueGetter<T> builder, {String name = '', bool asBuilder = false}) {
    final String code = _generateDiCode<T>(name);
    if (asBuilder) {
      _builders[code] = builder;
    } else {
      _dependencies[code] = builder();
    }
  }

  static T get<T>({String name = ''}) {
    final String code = _generateDiCode<T>(name);
    late T value;
    if (!_dependencies.containsKey(code) && !_builders.containsKey(code)) {
      throw Exception('Dependency for type $T with code $code not registered');
    } else if (_dependencies.containsKey(code)) {
      value = _dependencies[code];
    } else {
      value = _builders[code]!();
    }
    return value;
  }
} As in other solutions, we can implement identical entities by adding our own prefixes to them, and create singletons, as well as constantly new class instances. The second file: adding dependencies to the container itself so that it has something to create and return: import 'package:flutter/cupertino.dart';
import 'package:high_low/service/di/di.dart';
import 'package:high_low/service/routing/default_router_information_parser.dart';
import 'package:high_low/service/routing/page_builder.dart';
import 'package:high_low/service/routing/root_router_delegate.dart';

void initDependencies() {
  Di.reg<BackButtonDispatcher>(() => RootBackButtonDispatcher());
  Di.reg<RouteInformationParser<Object>>(() => DefaultRouterInformationParser());
  Di.reg<RouterDelegate<Object>>(() => RootRouterDelegate());
  Di.reg(() => PageBuilder());
} In the future, to add new dependencies, it will be enough to register their factories in this function and everything will work as it should. Routing The second aspect is one of the most difficult in any application. I will use the Navigator 2.0 approach ( great article on it if you haven't used it yet). here In fact, everything is not very complicated, and according to this scheme: We need to implement the following classes: RouteInformationProvider RouteInformationParser RouterDelegate Router I have already spoiled their implementation in the DI container, let's see what's inside. RouteInformationProvider Represents a provider of additional information that will be added to the URL that is being navigated and passed on to . In general, this is not a required piece of navigation logic in our case, so its implementation remains in question for now. RouteInformationParser RouteInformationParser It should parse the URL, extract the necessary parameters from it, and pass them further - to . Here is our implementation code (currently): RouterDelegate import 'package:flutter/cupertino.dart';
import 'package:high_low/service/routing/route_configuration.dart';
import 'package:high_low/service/routing/routes.dart';

class DefaultRouterInformationParser extends RouteInformationParser<RouteConfiguration> {
  @override
  Future<RouteConfiguration> parseRouteInformation(RouteInformation routeInformation) {
    return Future.sync(() => Routes.getRouteConfiguration(routeInformation.location ?? Routes.root()));
  }
} We are also interested in the class, here it is: RouteConfiguration import 'package:flutter/cupertino.dart';
import 'package:high_low/service/logs/logs.dart';
import 'package:high_low/service/routing/routes.dart';
import 'package:high_low/service/types/types.dart';
import 'package:json_annotation/json_annotation.dart';

part 'route_configuration.g.dart';

@immutable
@JsonSerializable()
class RouteConfiguration {
  const RouteConfiguration({
    required this.initialPath,
    required this.routeName,
    required this.routeParams,
  });

  const RouteConfiguration.empty({
    required this.initialPath,
    required this.routeName,
  }) : routeParams = const RouteParams(params: <String, String>{}, query: <String, String>{});

  factory RouteConfiguration.unknown() => RouteConfiguration.empty(initialPath: Routes.unknown(), routeName: Routes.unknown());
  factory RouteConfiguration.fromJson(Json json) => _$RouteConfigurationFromJson(json);

  final String initialPath;
  final String routeName;
  final RouteParams routeParams;

  Json toJson() => _$RouteConfigurationToJson(this);

  @override
  String toString() => prettyJson(toJson());
}

@immutable
@JsonSerializable()
class RouteParams {
  const RouteParams({
    required this.params,
    required this.query,
  });

  factory RouteParams.fromJson(Json json) => _$RouteParamsFromJson(json);

  final Json params;
  final Json query;

  Json toJson() => _$RouteParamsToJson(this);
} Here you can notice the appearance of another package - , it is needed to generate constructors and class methods for serialization to JSON and de-serialization from JSON. It must be installed together with a couple more: json_annotation dependencies:
  json_annotation: ^4.3.0
  #...

dev_dependencies:
  build_runner: ^2.1.4
  json_serializable: ^6.0.1
  #... If we talk about the functionality of the class itself, any incoming url is converted into it and from it we will take the parameters of interest to us for the further logic.
For example, for such an incoming deep link we get the following : RouterDelegate flutter run --route="/item/AAPL?interval=day" RouteConfiguration {
  "initialPath": "/item/AAPL?interval=day",
  "routeName": "/item/:itemCode",
  "routeParams": {
    "params": {
      "itemCode": "AAPL"
    },
    "query": {
      "interval": "day"
    }
  }
} This transformation of the url into a configuration takes place in the method: Routes.getRouteConfiguration(...) import 'package:high_low/service/routing/route_configuration.dart';

typedef RouteParamName = String;
typedef RouteParamValue = String;

const String itemCode = 'itemCode';

abstract class Routes {
  static String root() => '/';
  static String item(String itemCode) => '/item/$itemCode';
  static String unknown() => '/404';

  static List<String> names = [
    Routes.root(),
    Routes.item(':$itemCode'),
    Routes.unknown(),
  ];

  static RouteConfiguration getRouteConfiguration(String route) {
    if (route == Routes.root()) {
      return RouteConfiguration.empty(initialPath: route, routeName: Routes.root());
    }
    final Uri routeUri = Uri.parse(route);
    final List<String> routeSubPaths = routeUri.pathSegments;
    if (routeSubPaths.isEmpty) {
      return RouteConfiguration.empty(initialPath: route, routeName: Routes.unknown());
    }
    for (final String routeName in names) {
      final List<String> routeNameSubPaths = routeName.split('/').where((String segment) => segment.isNotEmpty).toList();
      if (routeNameSubPaths.length != routeSubPaths.length) {
        continue;
      }
      bool isTargetName = true;
      final Map<RouteParamName, RouteParamValue> params = {};
      for (int i = 0; i < routeSubPaths.length; i++) {
        final String routeSubPath = routeSubPaths[i];
        final String routeNameSubPath = routeNameSubPaths[i];
        final bool isDynamicSubPath = routeNameSubPath.contains(':');
        if (routeSubPath != routeNameSubPath && !isDynamicSubPath) {
          isTargetName = false;
          break;
        } else if (isDynamicSubPath) {
          params[routeNameSubPath.replaceFirst(':', '')] = routeSubPath;
        }
      }
      if (isTargetName) {
        return RouteConfiguration(initialPath: route, routeName: routeName, routeParams: RouteParams(params: params, query: routeUri.queryParameters));
      }
    }
    return RouteConfiguration.empty(initialPath: route, routeName: Routes.unknown());
  }
} This logic can be extended. For example - now this code will not process array query parameters, like , but on another way of specifying array parameters: - Flutter does not start with the following error: /item/AAPL?interval=month,day /item/AAPL?interval=month&interval=day ProcessException: Process exited abnormally:
Starting: Intent { act=android.intent.action.RUN flg=0x20000000 (has extras) }

/system/bin/sh: --ez: inaccessible or not found
Error: Activity not started, unable to resolve Intent { act=android.intent.action.RUN flg=0x30000000 (has extras) }
  Command: C:\Users\Me\AppData\Local\Android\sdk\platform-tools\adb.exe -s emulator-5554 shell am start -a android.intent.action.RUN -f 0x20000000 --ez enable-background-compilation true --ez enable-dart-profiling true --es route /item/AAPL?interval=month&interval=day --ez enable-checked-mode true --ez verify-entry-points true --ez start-paused true com.alphamikle.high_low/com.alphamikle.high_low.MainActivity In general, you can safely take this code as a basis, but you will still need to refine it for the specific URLs of your project. RouterDelegate import 'dart:async';

import 'package:flutter/material.dart';
import 'package:high_low/domain/main/ui/main_view.dart';
import 'package:high_low/service/di/di.dart';
import 'package:high_low/service/logs/logs.dart';
import 'package:high_low/service/routing/page_builder.dart';
import 'package:high_low/service/routing/route_configuration.dart';
import 'package:high_low/service/routing/routes.dart';

class RootRouterDelegate extends RouterDelegate<RouteConfiguration> with ChangeNotifier, PopNavigatorRouterDelegateMixin<RouteConfiguration> {
  RootRouterDelegate() : navigatorKey = GlobalKey();

  @override
  final GlobalKey<NavigatorState> navigatorKey;

  PageBuilder get pageBuilder => Di.get();

  final List<Page> pages = [];

  @override
  RouteConfiguration currentConfiguration = RouteConfiguration.empty(initialPath: Routes.root(), routeName: Routes.root());

  bool onPopRoute(Route<dynamic> route, dynamic data) {
    if (route.didPop(data) == false) {
      return false;
    }
    pages.removeLast();
    notifyListeners();
    return true;
  }

  Future<void> mapRouteConfigurationToRouterState(RouteConfiguration configuration) async {
    final String name = configuration.routeName;
    pages.clear();
    if (name == Routes.unknown()) {
      // openUnknownView();
      Logs.warn('TODO: Open Unknown View');
    }
  }

  @override
  Future<void> setNewRoutePath(RouteConfiguration configuration) async {
    Logs.debug('setNewRoutePath: $configuration');
    currentConfiguration = configuration;
    await mapRouteConfigurationToRouterState(configuration);
    notifyListeners();
  }

  @override
  Widget build(BuildContext context) {
    return Navigator(
      key: navigatorKey,
      pages: [
        pageBuilder.buildUnAnimatedPage(const MainView(), name: Routes.root()),
        ...pages,
      ],
      onPopPage: onPopRoute,
    );
  }
} This is just the basis of the delegate, but what's interesting here is the method, which is called from the method - which, in turn, processes the routing configurations coming here from . In the future, we will write navigation methods here. mapRouteConfigurationToRouterState setNewRoutePath RouteInformationParser Logging The last point is logging. Everything is quite simple here - I made a small wrapper on top of the library, which, in my opinion, provides some of the best logging capabilities. Now we can pass any arguments to the logging methods. logging import 'dart:convert';

import 'package:logger/logger.dart' as logger;

String _getJoinedArguments(dynamic p1, [dynamic p2, dynamic p3]) {
  String result = p1.toString();
  result += p2 == null ? '' : ' ${p2.toString()}';
  result += p3 == null ? '' : ' ${p3.toString()}';
  return result;
}

String prettyJson(Map<String, dynamic> json) {
  const JsonEncoder jsonEncoder = JsonEncoder.withIndent(' ');
  return jsonEncoder.convert(json);
}

final _logger = logger.Logger(
  printer: logger.PrefixPrinter(
    logger.PrettyPrinter(
      colors: true,
      printEmojis: false,
      methodCount: 0,
      errorMethodCount: 3,
      stackTraceBeginIndex: 0,
    ),
  ),
);

abstract class Logs {
  static void debug(dynamic p1, [dynamic p2, dynamic p3]) {
    _logger.d(_getJoinedArguments(p1, p2, p3));
  }

  static void info(dynamic p1, [dynamic p2, dynamic p3]) {
    _logger.i(_getJoinedArguments(p1, p2, p3));
  }

  static void warn(dynamic p1, [dynamic p2, dynamic p3]) {
    _logger.w(_getJoinedArguments(p1, p2, p3));
  }

  static void error(dynamic p1, [dynamic p2, dynamic p3]) {
    _logger.e(_getJoinedArguments(p1, p2, p3));
  }

  static void fatal(dynamic p1, [dynamic p2, dynamic p3]) {
    _logger.wtf(_getJoinedArguments(p1, p2, p3));
  }

  static void trace(dynamic p1, [dynamic p2, dynamic p3]) {
    _logger.v(_getJoinedArguments(p1, p2, p3));
  }

  static void pad(dynamic p1, [dynamic p2, dynamic p3]) {
    print(_getJoinedArguments(p1, p2, p3));
  }
} Conclusion At the moment, the most basic logic has been implemented, which is needed for further development of business functionality. The source code of the current part can be viewed . here

Stories, News & Mentions about COINALPHA

Coinalpha’s Stories on HackerNoon