Check out blog.quicknode.com for the latest articles, and our new Guides section for tutorials on web3 and blockchain! ✌️

We’ve Moved Our Blog! was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

While Infura is an awesome gateway to Ethereum, when you have a high-traffic decentralized application then you might have a need for maximum performance, non-funnelled access to the blockchain.

Yes you can run your own Ethereum node, but setting up and managing a blockchain node is a difficult, time- and resource-consuming task. Not to mention that it is your responsibility to keep your node up to date with node and network upgrades.

QuikNode is a so-called remote node service that gives you all the power of a full-node without running one yourself. They have a free plan for developers, and if your decentralized application is ready to scale up, they have membership plans for up to 10 million requests/day. This can make a world of difference in the way your decentralized application feels for your users.

Let’s create a free account and obtain a complimentary endpoint to the Ethereum blockchain. Go to the QuikNode website and sign up. After signing up and signing in, you are greeted by your complimentary node:

Your node comes with the following JSON-RPC web3 provider over HTTPS:

https://<your-node-name>.quiknode.pro/<your-token>/

Here’s how to plug your HTTPS endpoint in Delphi code. Launch Delphi, and then start a new project. Please make sure Delphereum and the dependencies are in your search path. Copy and paste the following example:

Please note that you will need to replace <your-node-name> and <your-token> in the example above.

The example above breaks down to this. After we have created a new instance of the Delphereum client, we will then call a function named web3.eth.blockNumber(). Because calls to the Delphereum library are asynchronous, the web3.eth.blockNumber function expects a so-called promise. Inside this promise, we get the number of the most recent block and prompt that number in a message box. Please note that we need to synchronise the execution state with the main thread, and that is what TThread.Synchronizedoes for us.

Congratulations! You have successfully connected your Delphi application to the Ethereum blockchain via QuikNode.

QuikNode, Ethereum and Delphi was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Today the team at QuikNode is excited to debut the result of 2.5+ years of grind, hustle, vision, and passion for building infrastructure for blockchain & Web3.

Since summer of 2017, we’ve launched thousands of Ethereum nodes; experimented with a variety of use-cases and applications; contributed to dozens of hackathons around the world; met some amazing, talented people; and never gave up on building a tool for developers and businesses to run web3 dApps.

Early on, we understood that setting up & managing blockchain nodes was a difficult, time- and resource-consuming task. Creators had a hard time keeping their applications ‘live’ during critical moments, and an even more difficult time managing their nodes at-scale.

Having been in the IT and web-hosting industry since the late 90’s, we applied our knowledge and expertise to create a product that abstracts the node layer, and “just works” — providing up-to-date (as well as historical) blockchain data to apps.

All this experience & drive to help #buidl the blockchain ecosystem has culminated to this latest version of QuikNode.io — and we’re super-proud to debut it today!

Quik-Summary:

v2 offers users both elastic, globally-balanced API service and Dedicated Node options for accessing Ethereum blockchain data.

Full and Archive sync data access is available, with JSON-RPC (over https://) and WebSocket (wss://) endpoints.

Available clients are Geth and Parity (API service runs on Parity).

Available networks are: ETH MainNet, Kovan, Ropsten and Rinkeby (Ethereum Classic [ETC] is available as a Dedicated Node only).

Bitcoin is available on MainNet and RegTest via Dedicated Node only (we are working on expanding this to our API service).

For more info, explore the brand-new QuikNode.io website!

Users can now create a free account and obtain a complimentary API endpoint to either MainNet, Ropsten, Kovan or Rinkeby networks on Ethereum blockchain. ☝️

Users can manage multiple nodes under their account, both API and Dedicated.

New to v2 are request analytics — call breakdown, response status, and over time.

Average response time metric is coming soon!

Users can configure a Dedicated Node (ETH, BTC, ETC) to their needs, and launch in 8 locations around the world.

New users have QuikStart guides in the UI, on how to utilize their endpoint.

Both API and Dedicated Nodes come with QuikNode Boost technology: an acceleration layer for maximum performance.

Boost is your secret weapon for an ultra-fast dApp. Boost accelerates your Ethereum node requests with an intelligent caching layer.

All QuikNode services are monitored for health and performance: 99.9%uptime for any single node, and 99.99% for the API service.

Developer? Already run a dApp? Business operator? There is a QuikNode for you.

Already have a primary web3Provider? Use QuikNode to make your application fault-tolerant by adding in a secondary, backup provider.

Questions? Message us in-app (via Intercom), Tweet us @QuikNode, or join us in Discord chat.

Ready?

Join the network processing over 500 million requests per month.

Get started now for free at QuikNode.io 🚀

Established in 2017 QuikNode’s mission is to help blockchain ecosystems scale by providing accessible core infrastructure. v2 is a clear expression of a vision to be able to develop & run blockchain applications effortlessly, to build the #web3. ✌️

The All-New QuikNode v2 was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

0xGames — an international all-star team of IT pros with deep game development and blockchain technology chops has released 3 next gen blockchain, open-economy games (plus one on the way).

Woven in beautiful 2D and 3D graphics, exciting gameplay, fascinating storyline and immersive soundtracks, players can profit with crypto, while trading or winning NFTs.

These award winning games can be accessed across PC, MAC, iOS and Android platforms plus about any blockchain platform imaginable.

But in order for games like 0xUniverse and 0xBattleship to maintain peak performance, 0xGames needed a high performing, secure Ethereum node that’s simple to integrate with unlimited call requests.

CEO Sergey Kopov weighs in: “We use a Ethereum node to run transactions and receive events. We tried to maintain an Ethereum node ourselves. After that we tried Infura and Alchemy. And in the end, we choose Quiknode as the simplest and most reliable solution.”

Teaming up with QuikNode, 0xGames has enjoyed a worry free experience with no call request limits from the fastest, most reliable node provider on the planet.

Since 2017, QuikNode has helped amazing blockchain projects like 0xGames take off — and we’d love to help you with yours!

Now with a Free tier available for you to develop and test your Ethereum blockchain project (which is easily upgradable for when the time comes).

You can get access to Ethereum MainNet in minutes by setting up an account here:

👉 Create Your Free QuikNode Account 👈

Get Started Today!

QuikNode Customer Spotlight: 0x.Games was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Updated 12/25/2019: Updated Tutorial Here

Step 1: Get a QuikNode.

Step 2: Expand the instructions for MyEtherWallet at the bottom of your QuikNode user interface:

Step 3: Following the instructions, go to MyEtherWallet.com and find the Node Switcher (top right)… click “Add Custom Node”:

Step 4: Fill out the fields using the info from your node user interface:

Step 4.5 (optional): Leave the chain as ETH, unless you’re an advanced user and have launched your QuikNode with an alternate chain.

Step 5: Click “Save & Use Custom Node” — if you entered everything in correctly, you will receive a successful connection notice:

That’s it, you’re finished! Proceed to use MyEtherWallet regularly — but now with your own, personal Ethereum node!

Stuck or have questions? Tweet us @QuikNode!

How To Set Up QuikNode with MyEtherWallet was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

How to set up your QuickNode with 3 popular Wallet/Account services

MyCrypto

1) Click the Node Selector in top right corner

2) Click “Add Custom Node” at the bottom of the window that pops up

3) Enter a name (any), select the network (ETH = MainNet), and copy/paste your Web3 endpoint

4) Click “Save & Use Custom Node” — and you’re all set!

MetaMask

1) Open the MetaMask plugin, click the Network Selector at the top

2) Select “Custom RPC” at the bottom

3) Enter a name (any), copy/paste your Web3 endpoint (be sure to include the “/” at the end!), enter a ChainID (1 for MainNet, check here for others), click “Save”

4) Your all set!

MyEtherWallet

1) Open access to your wallet/account, click “Change” under Network

2) Flick “Add Custom Network/Node” and enter a name (any) and your Web3 endpoint, click Save

3) You will see that your network has switched to QuikNode, all set!

Don’t see your favorite wallet/tool/service on this list?

Tweet us @QuickNode and we’ll put up a guide for it!

Using QuikNode with MetaMask, MyCrypto, MyEtherWallet (updated) was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Access 25+ chains, tools and APIs to help you build the highest-quality Web3 applications!

Started in 2017

QuickNode first launched supporting only Ethereum (ETH), running on OpenEthereum (fka Parity) client, in a single dedicated node instance, on a single cloud provider.

Today QuickNode API supports 25+ chains across 35+ networks, utilizing multiple clients, across 10+ regions worldwide, 5+ cloud & bare-metal providers, with multiple middle layers to enhance performance, reliability and overall user experience.

The result is the most powerful Web3 infrastructure in the world: a highly-available, multi-cloud, geo-balanced, redundant node network.

The Magic Behind QuickNode API

QuickNode gives Web3 developers instant access to Enterprise-grade infrastructure — the same used by Coinbase, Adobe, Twitter, Dune, Chainlink, 1inch, and many more!

We’ve spent the last 5 years learning, building, iterating, working with thousands of projects, applications and developers to create the QuickNode platform.

Accessing Ethereum, Solana, Bitcoin, Gnosis (xDai), Polygon (Matic) + zkEVM, Fantom, Celo, Optimism, Arbitrum (incl. Nova), Binance Chain (BSC/BNB), Avalanche (AVAX), TRON, Algorand, Harmony, NEAR, Base, Flow, Aptos (APT), Polkadot (DOT), XRP Ledger, Stellar (XLM), Scroll, zkSync Era, Immutable zkEVM (IMX), and Stacks (STX) blockchains — across their Mainnet, Testnet, and Devnet networks — has never been easier.

Behind every QuickNode API endpoint sits a global network of nodes — globally-distributed across 10+ regions, geo-balanced, multi-cloud, highly-available & auto-scaling — at your service, on-demand.

Every request sent to your QuickNode API endpoint is intelligently routed to the nearest node cluster based on IP, ensuring lowest latency.

Read more on the architecture and why businesses choose QuickNode for Web3 infrastructure.

Highly reliable, our node network is distributed across 5+ unique cloud & bare-metal providers, in US East, West; UK; Europe; India; Singapore, Tokyo and Australia — with automatic failover.

Our internal monitoring systems make sure all nodes in the network serving requests are healthy, and kick out & replace nodes which are misbehaving.

We also monitor for performance, things like average latency, response time, and http response codes, to ensure every request is served quickly and reliably.

Read more on performance benchmarks among Web3 providers.

Based on network performance metrics, we automatically provision additional capacity when certain thresholds are reached, to maintain consistent performance and mitigate “noisy neighbor” effect — the network scales to meet virtually any volume, on-demand.

Need the power of 10 nodes to handle your spike in traffic? You got it! Back down to 3 nodes tomorrow? No problem!

All the core network features are baked-in to the cost of usage (take a look at pricing here) — you only pay for what you use!

QuickNode API makes the Web3 infrastructure layer transparent for you.

Simply send the traffic, and we scale to meet your needs — every request is guaranteed to be fast and served from a healthy node nearby.

All you have to do is focus on building the best version of your application, and leave the infrastructure heavy lifting to us!

–

Middleware

We do several things under the hood to make QuickNode fast and reliable:

Request Routing

When you send a request to your QuickNode API endpoint, it is first routed to the nearest location based on IP.

Then, another engine takes care of routing per call type. Different node clients, configurations, and layers handle different calls.

For example, eth_call is handled differently than a debug_traceCall or a simple eth_blockNumber.

We actively benchmark clients (like Geth, Erigon, OpenEthereum, etc…) for reliability & performance, and utilize each for their benefits.

Our request routing engine not only routes for speed based on geo-location, but also by call type!

Caching & Indexing

Many requests on our network are duplicated, identical. There are certain responses which can be cached and served from memory, reducing response times by 100x (source)!

We also keep an index of certain responses, ones which are constant or in finality.

The first time a response is issued, the node does the necessary compute and returns a response. This response is indexed and stored in a high-performance database.

Each consecutive time this same data is requested, it is served from an index, skipping the compute part and allowing for an order of magnitude faster performance & response time.

Concurrency

Unlike a single Dedicated node, QuickNode API automatically splits your request across multiple nodes in parallel. This yields significantly faster response times vs. one single node handling all the requests.

But what about data consistency?

We have logic and additional layers to address that, ensuring the data you receive is accurate and consistent!

Failover

Our team comes from over 2 decades of experience in building global networks and distributed systems. We have war stories of underwater fiber cuts, force majeure events, and hosting providers going dark (happened with AWS, Azure, GCP) .

This is why we built QuickNode with a multi-region and multi-provider mindset; not bound by any one provider or geographic region.

If we detect an issue, we can reroute the traffic to a different provider or region, on-the-fly, with minimal impact (in most cases, it’s completely transparent).

–

Add-Ons

Get access to cross-client APIs like debug and trace, as well as historical data back to the genesis block — using the same endpoint!

Graph API

Fetch powerful market insights, trading data, transactions by wallets and contracts, cached NFT images, and more using GraphQL. Learn more.

Marketplace

An entire universe of infrastructure at your fingertips! Select from dozens of add-ons — like Subgraph Hosting by Satsuma, Blockbook API, Flashbots Protect, or Gas API from Blocknative — that make building super-powered dApps easier than ever. Learn more.

QuickAlerts

QuickAlerts is a powerful mutli-tool that delivers real-time notifications for on-chain events. Create a custom feed of blockchain data and stay informed with real-time alerts. Learn more.

NFT API

Build your dream NFT project faster, with the new NFT API from QuickNode. Our NFT API lets you find any NFT, verify ownership, and pull transaction history and key collection information, without sorting through individual smart contracts.

Token API

Access ERC20 data instantly! No need to query multiple ERC20 contracts for token data. With QuickNode Token API, get ERC20 data with a single method call! Learn more.

IPFS

Use QuickNode to upload, store, manage, and retrieve data on the IPFS network through our pinning services and dedicated gateways. Learn more.

Developer SDK

The QuickNode SDK is designed to facilitate interaction with QuickNode infrastructure. Developers can effortlessly leverage the Graph API to access a wide range of valuable data and insights, including market insights, trading data, wallet and contract transactions, cached NFT images, and much more. Learn more.

Advanced Mempool Service

QuickNode API utilizes a custom mempool service which was developed in-house, and takes advantage of the mempool data from all the nodes we run, all over the world. Instead of fetching from a single node in 1 location, we aggregate our entire network’s mempool data and serve it to you as soon as any one of our nodes spots a transaction.

Security

The security of your data and integrity of our systems is important to us. QuickNode is SOC2 certified, with support for popular Enterprise requirements.

Customer Service

Included with your paid QuickNode subscription is access to our team of Web3, platform, and billing experts. Get help from the community in our Discord, open a ticket for email support, or get VIP live chat via Slack and Telegram. We’ll make sure you are happy!

What about pricing?

The pricing model for QuickNode API is usage-based, pay-as-you-go (on-demand) pricing, with the best value of any Web3 provider!

With QuickNode API, you are guaranteed the best performance: every call will be fast, since the platform utilizes the entire global node network and auto-scales to meet demand.

See our Pricing page for full details!

Just starting out?

We have a knowledge-base of over 100 high-quality guides & tutorials to help you get started — from DeFi bots and NFT minting, to Vyper and Solidity — we have you covered.

Visit our Guides page, YouTube channel, or check out the API docs — come build with us!

So, what are you waiting for?

Get started for free with QuickNode today on QuickNode.com!

Want to learn more about QuickNode?

Check out our Blog page!

Have feedback, questions, a feature suggestion, or just want to help build the future of web3 infrastructure?

Contact us here, on Twitter @QuickNode, or ping us on DISCORD!

Introducing QuikNode API and the Blockchain Developer Cloud 🚀 was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Service and Features Overview

(this article is outdated. visit the Official Quicknode Blog for latest info & details!)

QuickNode is your high-performance access to 70+ blockchains, including Ethereum, Gnosis (xDAI), Polygon (Matic) + zkEVM, Binance Smart Chain (BNB/BSC), Avalanche, Fantom, Solana, Optimism, Arbitrum (+Nova), Algorand, Aptos, Celo, Stacks, Near, Flow, Base, TRON, Polkadot, zkSync Era, XRP Ledger, Stellar, Scroll zkEVM, Immutable zkEVM, and Bitcoin networks.

Get instant access to XDAI, BTC, SOL, FTM, OP, ARB, APT, CELO, BSC, IMX, MATIC, BASE, FLOW, NEAR, TRON, DOT, STX, XRPL, XLM, SCROLL, AVAX, ETH MainNet, TestNet and DevNet networks — register now.

QuickNode - Blockchain API and Node Infrastructure | Ethereum, Solana, Polygon, BSC + More

Behind every QuickNode API endpoint sits a global network of nodes — globally-distributed across 10+ regions, geo-balanced, multi-cloud, highly-available & auto-scaling — at your service, on-demand.

Every request sent to your QuickNode API endpoint is intelligently routed to the nearest node cluster based on IP, ensuring lowest latency.

Highly reliable, as the network is distributed across 5+ different cloud & bare-metal providers, in US East, West; UK; Europe; India; Singapore; Tokyo and Sydney — with automatic failover in case of an issue.

Read more on the architecture and why businesses choose QuickNode for Web3 infrastructure.

Our internal monitoring systems make sure all nodes in the network serving requests are healthy, and kick out & replace nodes which are misbehaving.

We also monitor for performance, things like average latency, response time, and http response codes, to ensure every request is served quickly and reliably.

Based on network performance metrics, the network has auto-scaling capabilities to meet virtually any volume, on-demand.

Need the power of 10 nodes to handle your spike in traffic? You got it! Back down to 3 nodes tomorrow? No problem!

All the core network features are baked-in to the cost of usage (take a look at pricing here) — you only pay for what you use!

QuickNode API makes the Web3 infrastructure layer transparent for you.

Simply send the traffic, and we scale to meet your needs — every request is guaranteed to be fast and served from a healthy node nearby.

All you have to do is focus on building the best version of your application, and leave the infrastructure heavy lifting to us!

Ready to get started?

After login, you’ll see the dashboard with ability to Create Nodes, Add Team Members, get Support, and manage your Nodes — all in one place.

Clicking on the node will bring you to the Node dashboard, where your Web3 URLs (rpc endpoint, httpProvider & websockets) is shown, as well as Getting Started guides:

For more guides & tutorials, including how to set up with ethers.js, web3.py, ethereum.rb, and write your first smart-contract in Solidity, check our guides page!

How do I set up my code?

Check out our RPC documentation: QuickNode.com/docs

In web3js, for example, copy/paste the httpProvider link like so:

const Web3 = require('web3')

const httpProvider = "https://your-node-name.quiknode.pro/hash/"

var web3 = new Web3(new Web3.providers.HttpProvider(httpProvider));

Ready to get started?

Sign up here 👉 QuickNode.com and try QuickNode free with a Discover plan!

Features

Analytics

See what your node is doing with detailed call/request metrics:

Security

Lock down (or open up) your endpoint as much as you wish (including multiple Auth token, JWT, referrer gating and domain masking support)!

NFT Tools

Easily grab NFT data with a single API call (available on Ethereum and Solana: read more).

Token API

Access ERC20 data instantly! No need to query multiple ERC20 contracts for token data. With QuickNode Token API, get ERC20 data with a single method call! Learn more.

Graph API

Fetch powerful market insights, trading data, transactions by wallets and contracts, cached NFT images, and more using GraphQL. Learn more.

QuickAlerts

QuickAlerts is a powerful multi-tool that delivers real-time notifications for on-chain events. Create a custom feed of blockchain data and stay informed with real-time alerts. Learn more.

IPFS

Use QuickNode to upload, store, manage, and retrieve data on the IPFS network through our pinning services and dedicated gateways. Learn more.

Marketplace

An entire universe of infrastructure at your fingertips! Select from dozens of add-ons — like Subgraph Hosting by Satsuma, Blockbook API, Flashbots Protect, or Gas API from Blocknative — that make building super-powered dApps easier than ever. Learn more.

Developer SDK

The QuickNode SDK is designed to facilitate interaction with QuickNode infrastructure. Developers can effortlessly leverage the Graph API to access a wide range of valuable data and insights, including market insights, trading data, wallet and contract transactions, cached NFT images, and much more. Learn more.

Certified Infrastructure

The security of your data and integrity of our systems is important to us. QuickNode is SOC2 certified, with support for popular Enterprise requirements.

Customer Service

Included with your paid QuickNode subscription is access to our team of Web3, platform, and billing experts. Get help from the community in our Discord, open a ticket for email support, or get VIP live chat via Slack and Telegram. We’ll make sure you are happy!

FAQ

Which RPC calls and modules are supported?

Check out the QuickNode Docs for more info!

Does QuickNode API have access to Archive Node data?

Absolutely! You’ll have access to all the data since Genesis block on all plans.

Using a different provider already?

It’s easy to switch. Just swap your request URL with the one from QuickNode — done!

Just starting out?

We have a knowledge-base of over 100 high-quality guides & tutorials to help you get started — from DeFi bots and NFT minting, to Vyper and Solidity — we have you covered.

Visit our Guides page, YouTube channel, and check out the API docs — come build with us!

Develop on ETH, xDAI, SOL, OP, ARB, CELO, FTM, BSC, ALGO, AVAX, MATIC, BASE, NEAR, FLOW, STX, APT, ONE, TRON, DOT, and BTC Now!

Sign up now to access QuickNode API for free, and start with Web3 today!

What is QuikNode API? was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

What to look for when using private keys with your dApp

Key management is a big concern in the cryptocurrency industry as keys give access to addresses, and addresses can hold funds. If keys are handled incorrectly, users could find their funds missing, without permission…

Sure, there are ways to mitigate an entire heist on your funds, such as using a MultiSig wallet, but let’s talk about the vast majority of users who aren’t using a MultiSig.

In recent years, key management has improved for users interacting with decentralised apps, as developers are starting to separate concerns from the main app logic and signing mechanisms (i.e. key management).

Let’s take EtherDelta as our first case study — a very popular exchange in 2017.

EtherDelta is a decentralised trading platform for Ether and ERC20 tokens. It launched on Ethereum MainNet in 2016. It was the absolute top place at the time for people to trade tokens in a true, decentralised manner… on-chain, so it bought a lot of good attention to the technology (and unwanted attention from scammers and phishers).

One of the main ways for users to trade on EtherDelta was to “import their account” by inputting their raw private key into a text box, which “behind the scenes” would store it in the browser LocalStorage, unencrypted in plaintext.

Let’s discuss the UX aspects of this first. The technical decision to save the imported account saves the user from importing it again on multiple visits, decreasing their inputs and allowing them to do what they wanted; trade.

Think of this like the “Remember Me” checkbox on web2 login boxes — allowing the user to use your product quickly without worrying about inputting authentication details manually.

This is, pretty much, the only advantage for this decision (and done poorly).

The privacy and security implications for this decision are enormous.

Although convienent to the end user to reduce inputs when visiting each time to trade, EtherDelta could have done one or all of the following;

• Remove key management entirely from the app and promote the use of something like MetaMask — pass the signing mechanism to a dedicated application
• Encrypt the raw private key client side with an enforced strong password

Having the plaintext secret in LocalStorage is leaving your funds open to;

• Malicious browser extensions with read permissions (though you’d probably have bigger problems)
• Someone looking at your unlocked machine and checking LocalStorage directly
• Software able to read an unencrypted secret on an Internet-connected machine
• If someone is using a shared machine, it is not communicated to them that their secrets would be saved

It also promotes bad behaviour to users as they are being trained to input their raw private key to the Internet, as well as teaching them that the main application logic and key management are intertwined and not separate concerns.

Security is inversely proportional to convenience

Applications that promote convenience to their end users over security are arguably losing user attraction.

For example, if we ignore the different math behind EtherDelta and Uniswap, Uniswap achieves the “near-same” as EtherDelta without the use of concerning key management inside the main application — it relies on a user having a web3 enabled browser; where key management (and transaction signing) is a separate concern.

Arguably the ecosystem has evolved and it is not how it was when it first started, where the only way to interact with the blockchain was via the command line — something that would scare unfamiliar users, as it is a daunting task to learn and memorise specific commands to sign a transaction, for example.

An example of a more mature key management solution is WalletConnect. If implemented correctly within a dApp, the key management and application logic are totally separate concerns — meaning a dApp does not have wallet-like features (like in EtherDelta).

WalletConnect is a simple protocol used by mobile wallets to sign transactions remotely from your phone.

Instead of copy and pasting your private key from device to device which exposes to malicious attackers, you can simply scan a QR code to connect to your mobile wallet in an end-to-end encrypted connection.

Once you scan the QR code the application on another device can request messages and transactions to be signed securely on your phone and you can control from your wallet when to end the session.

Using WalletConnect makes it easy to manage your private keys from your phone while using applications on different desktops and even other devices like tablets, POS systems and TVs.

It’s architecture is completely free and open-source and can be used by any wallet or application. Currently WalletConnect is supported by 10 wallets.

— Pedro, WalletConnect

A setup where a dApp relies on third-party key management solutions only needs logic to tell the third-party signing mechanism different parts of the transaction to sign — this can increase both UX and security aspects for the user;

• The user will get a familar UI when confirming and signing transactions
• The user is taught that secrets, such as a private keys, are not to be known by applications — this would inturn help them not fall victim to potential specific phishing scams where they’d otherwise be ok entering their secrets on an online form because “it’s what I always do to use a dApp”
• The user is limiting their attack surface. Instead of having their secrets readily available stored across multiple browser in multiple domain LocalStorage objects, the user only has to protect one device that they know should be the only thing holding their secrets

MyCrypto, for example, made the decision to drop raw secrets from their web application (private keys, mnemonic phrases, keystore files), without losing any user experience using the application at the cost of a security effort because it still allows for many third-party key management applications to interact with the app.

This means total separation of application logic and your secrets on the web app (which you can also compile and run yourself).

Tip: there is a Desktop application for those users who wish to use raw secrets/keys

Having said that, key management is not just about how signing mechanisms work within dApps — it includes, amongst other things, the process of generating keys too. There have been many iterations on user experiences and interfaces to create a new “wallet”, and many public audits done to verify how secure solutions are at generating an entropy-strong secure key for the user.

This isn’t without its risks, however, as there have been multiple “backdoors” in key generation in recent years. One example is one that MyCrypto reported on in May 2019 — Disclosure: Key generation vulnerability found on WalletGenerator.net — potentially malicious.

Key management may be a difficult task to handle in the web3 world, but I urge dApp developers to develop their dApp and rely on the third-party applications that are dedicated to handling keys, for all the reasons talked about above.

Let us know your thoughts, questions, and maybe even share some of your cahllenges in web3. Thanks for reading this!

dApp Key Management: UX and Security was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Working with Web3j — A Java library for building on Ethereum

Enterprises all over the world use Java to build scalable systems which we use in our daily lives. Today, we will talk about Web3j — a library written in Java for Ethereum developers!

What is Web3j?

Web3j Java library to expose Ethereum JSON RPC APIs. You can use it for building web, mobile, or any other type of applications. The web3j documentation describes:

web3j is a highly-modular, reactive, type-safe Java and Android library for working with Smart Contracts and integrating with clients (nodes) on the Ethereum network:

What does Web3j support?

Web3j has rich support of Ethereum JSON-RPC:

• Complete implementation of Ethereum’s JSON-RPC client API over HTTP and IPC
• Ethereum wallet support
• Auto-generation of Java smart contract wrappers to create, deploy, transact with and call smart contracts from native Java code (Solidity and Truffledefinition formats supported)
• Reactive-functional API for working with filters
• Ethereum Name Service (ENS) support
• Support for Parity’s Personal, and Geth’s Personal client APIs
• Support for ERC20 and ERC721 token standards
• Comprehensive integration tests demonstrating a number of the above scenarios
• Command-line tools
• Android compatible
• Support for JP Morgan’s Quorum via web3j-quorum

Additionally, it also provides ENS and Wallet support 😎.

Moreover, it supports Quorum: a blockchain framework created by JPMorgan (Chase, the bank!).

Prerequisite

• Java ≥ version 8
• Maven
• Any Java IDE (I am using IntelliJ Community version)
• Solc (Solidity compiler)
• A QuikNode (QuikNode.io)
• Web3j command-line tools

Note: we’re using Ubuntu bionic (18.04)

Install Solc compiler

We need to install the Solidity compiler… we will use it to compile our Smart Contact later. Check here for a detailed installation guide.

sudo add-apt-repository ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install solc

Setting up the project

Let’s create a new project and import Web3j dependency using Maven.

<!-- https://mvnrepository.com/artifact/org.web3j/core -->
<dependency>    
   <groupId>org.web3j</groupId>    
   <artifactId>core</artifactId>    
   <version>4.5.5</version>
</dependency>

Connecting to Ethereum Blockchain using Web3j

Let’s begin to play!

First, we will connect to the Ethereum blockchain using QuikNode and Web3j.

Note: If you have any problems following the tutorial, we’ve attached the GitHub repo at the end.

Web3j web3 = Web3j.build(new HttpService("YOUR_QUIKNODE_URL"));

Web3ClientVersion web3ClientVersion = web3.web3ClientVersion().send();

String clientVersion = web3ClientVersion.getWeb3ClientVersion();System.out.println("Client version" + clientVersion);

Here we are simply connecting to Ethereum blockchain using QuikNode and printing our Ethereum client version.

Creating an Ethereum Wallet

Let’s create an Ethereum wallet now using Web3j. Web3j provides full wallet management functionality. We will use WalletUtils for this purpose.

Here we are specifying our wallet password and the path where wallet file will be stored. I have added my own password and directory according to my system.

String walletPassword = "trumpshouldbeimpeached";
String walletDirectory = "/home/batman/wallet/"; //add your own wallet directory path

String walletName = WalletUtils.generateNewWalletFile(walletPassword, new File(walletDirectory));System.out.println(walletName);

Load Ethereum Wallet

Now let’s see how we can load our wallet we just created and get a new address from it.

Credentials credentials = WalletUtils.loadCredentials(walletPassword, walletDirectory + "/" + walletName);

String accountAddress = credentials.getAddress();System.out.println("Account address: " + accountAddress);

Subscribing for Ethereum Events

Events are important part of Ethereum blockchain and serve as a logging mechanism for Ethereum blockchain State changes.

Subscribing for New Blocks

Every few seconds (13, on average), a new Ethereum blocks get mined. Let’s subscribe to that:

Subscription subscription = (Subscription) web3.blockFlowable(false).subscribe(block -> {    System.out.println(block.getBlock().getHash());});

Subscribing for New Transactions

Blocks contain transactions; we can subscribe to them too:

Subscription subscription = (Subscription) web3.transactionFlowable().subscribe(tx -> {    System.out.println(tx.getHash());});

Subscribing for Pending Transactions

Every time a transaction gets created, it first goes into the mempool. From the mempool, miners pick up transactions to mine. Until a miner picks up a transaction, it’s remains in pending status. Let’s subscribe to pending transactions now.

Subscription subscription = (Subscription)web3.pendingTransactionFlowable().subscribe(tx -> {   System.out.println(tx.getHash());});

Subscribing to Smart Contract Events

Ethereum allows Smart Contracts. Subscribing to Smart Contract events is a very important use-case while building dApps (decentralized applications) on Ethereum.

The SimpleBank.sol Smart Contract

We have created a SimpleBank Smart Contract which emits a Deposit event when someone deposits in our Bank.

pragma solidity ^0.5.8;

contract SimpleBank {
    uint8 private clientCount;
    mapping (address => uint) private balances;
    address public owner;

    event LogDepositMade(address indexed accountAddress, uint amount);

    constructor() public payable {
        owner = msg.sender;
        clientCount = 0;
    }

    function enroll() public returns (uint) {
        if (clientCount < 3) {
            clientCount++;
            balances[msg.sender] = 10 ether;
        }
        return balances[msg.sender];
    }

    function deposit() public payable returns (uint) {
        balances[msg.sender] += msg.value;
        emit LogDepositMade(msg.sender, msg.value);
        return balances[msg.sender];
    }

    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
        // Check enough balance available, otherwise just return balance
        if (withdrawAmount <= balances[msg.sender]) {
            balances[msg.sender] -= withdrawAmount;
            msg.sender.transfer(withdrawAmount);
        }
        return balances[msg.sender];
    }

    function balance() public view returns (uint) {
        return balances[msg.sender];
    }

    function depositsBalance() public view returns (uint) {
        return address(this).balance;
    }
}

You can deploy this contract using Web3j, which we will see in our next tutorial.

For now, we will deploy our contract using Remix (an online Solidity IDE).

After deployment, save your contract’s address somewhere (we will need later in the tutorial).

Now we need to compile our SimpleBank Smart Contract.

For this, we will use solc compiler.

Here replace <contract>.sol with our SimpleBank.sol, and also provide an output directory:

$ solc <contract>.sol --bin --abi --optimize -o <output-dir>/

Web3j provides a command-line tool to generate a Java Wrapper class for your Solidity Smart Contract. To install the Web3j command-line tool check here.

Now we’re ready to generate our Smart Contract wrapper class using the below command:

web3j solidity generate -b /path/to/<smart-contract>.bin -a /path/to/<smart-contract>.abi -o /path/to/src/main/java -p com.your.organisation.name

After replacing arguments, in my case this command was:

web3j solidity generate -b SimpleBank/SimpleBank.bin -a SimpleBank/SimpleBank.abi -o ~/IdeaProjects/quiknode/src/main/java/ -p com.simplebank

This will generate a Java class SimpleBank on our given path.

Getting an Instance of Smart Contract

Now let’s get an instance of our smart contract so we can interact with it.

SimpleBank simpleBank = SimpleBank.load("0x7208b4883a4dF0F3e5cD084F2F9C579e7b622A38",web3, credentials , new DefaultGasProvider());

Note: Here 0x7208b4883a4dF0F3e5cD084F2F9C579e7b622A38 is our Smart Contract address, deployed on the Ethereum blockchain.

Now we can listen to Deposit event from our Web3j.

simpleBank.logDepositMadeEventFlowable(DefaultBlockParameterName.EARLIEST,DefaultBlockParameterName.LATEST).doOnError(error -> System.err.println("The error message is: " + error.getMessage()))        .subscribe(logDepositMadeEventResponse ->                System.out.println(logDepositMadeEventResponse.amount));

SimpleBank class creates a logDepositMadeEventFlowable method that we can use to subscribe to Deposit events.

Once we have the event, we are printing the deposit amount, which emits with the deposit event.

In the next tutorial, we will deep-dive into transactions with Web3j and calling SimpleBank contract methods.

Full Code — Here is the complete code on Github.

About QuikNode

QuikNode.io is building infrastructure to support the future of Web3. Since 2017, we’ve worked with hundreds of developers & companies, helping scale dApps and providing high-performance Ethereum nodes. We’re working on something interesting from the past few months and will be launching soon, so subscribe to our newsletter for more updates!! 😃

Ethereum for Java Developers (Web3j) was originally published in Quicknode on Medium, where people are continuing the conversation by highlighting and responding to this story.