Dev Null Productions

The Blog

Zerp Tracker

Last month Dev Null Productions launched our latest product Zerp Tracker, a persistent XRP transaction tracker through which server-side filters can be setup for instant notification of ledger activity. With Zerp Tracker, expressions are created to hone in on specific transactions to match and alerts sent via email, sms (text message), and webhooks (for programmatic integration). This tool is perfect to monitor your account (or any others) for incoming and outgoing transactions, receive notifications on the movement of money, or watch for any other type of activity that you are interested in.

To begin, sign up for an account at zerptracker.com by clicking the Register Link in the upper right. On mobile devices, this may be accessed through the mobile popup menu:

Click on images to expand

You will need to provide a valid email, and confirm your account by clicking the link sent to that. Once confirmed, login and click on Add New Filter to setup your first filter to match XRP Blockchain activity:

Zerp Tracker provides several example expressions to get you started, to access click the (?) icon under the filter input box on the main page:

The filter input here can be used to test expressions in real time against the live transaction stream, but it should be noted that until you save the form creating a new filter, you will not receive alerts via email, text message, etc. and once you navigate away from this page your filter will be gone!

Expressions are specified via JSONPath a powerful language which can be used to match the exact transaction fields and hone in on exactly the types of transactions you are interested in. You can read more about JSONPath via our help portal here. Also be sure to read common gotchyas to mitigate any issues you may have in crafting the exact expression to match the activity you are interested in.

If you are not interested in setting up expressions, don't fret! Zerp Tracker ships with a library of pre-built pluggable expression-templates to select from. Simply pick the category of activity which you are interested in, fill in fields for the account to monitor, currencies to watch, and more, and Zerp Tracker will take care of crafting the expression required to match your criteria!

Finally select the endpoint(s) which you would like to receive notifications, whether it be via email, text message, or URL. The later option is perfect for setting up a trading bot, forensics solution, or any other automated system to be notified on XRPL activity.

Click Save and you're done... Zerp Tracker will take care of the rest! Soon after XRPL transactions are matched, you will receive notification via the configured endpoint. If you would like to change the rate at which you receive notifications click Settings to configure batch size and notification time:

To view filter details, simply click the transaction name (or if on a mobile device, select the filter from the list). From here you can inspect actual live transactions which your filter matched and test your filter against a variety of pre-captured transactions built-into Zerp Tracker by clicking 'test' in the navigation.

Finally be sure to checkout the help page for in-depth details pertaining to these topics and more. Any questions may be addressed to Dev Null Productions by submitting the following form

Happy Zerping!

XRP 2020 - Quarter 2

Q2 saw a continuation of the XRPL trends from Q1 with ledgers closed, transactions sent, and offers created consistent with those from the last quarter (daily averages differing by -1%, -6.9%, and 4.5% respectively). The average number of payments saw a more significant change, declining from 115,975.70 per day to 65,783.23 (-43.27%), though an above-average payment volume early on in the January timeframe skewed the averages from that quarter. This was likely a continuation of the excessive transaction activity that we noted from last fall/winter, as once this tapered off, payment volume adhered to a consistent / bound range. The number of accounts created saw a nice uptick in Q2, increasing from an average of 695.41 per day to 905.97 (30%).

As with other reports we start with the most stable metric, ledgers closed. In the months of April, May, and June, 2,024,347 total ledgers were closed with a weekly average of 155,511.25 ledgers and a daily average of 22,492.74.

Click on an image to expand

The network saw 84,666,157 total transactions last quarter with a daily average of 940,735.08 transactions and a weekly average of 6,549,072.25. The standard deviation from the daily average was 74,690.86 transactions, or 7.94%. Overall this was one of the most consistent metrics that we collect with transactions being issued to the network at a constant rate with low variance for the entire quarter, as seen in the charts below:

102,148.65 XRP was burnt in fees during the quarter, with a daily average of 1,134.99 XRP and a weekly average of 8,227.53. Some anomalous transactions throughout the the quarter resulted in very large spikes in fees paid. The median burn rate was 5,094.96 XRP per week and 625.03 XRP per day.

Fees in these charts are in drops or one-millionth of an XRP

As far as specific transaction types:

  • 5,920,491 total payments
  • Payment averages: 448,789.42 (weekly), 65,783.23 (daily)
  • Daily payment standard deviation: 19,822.76 (30%)
  • 64,155,972 total offers
  • Offer averages: 4,966,021.58 (weekly), 712,844.13 (daily)

The network saw 81,538 new accounts last quarter, at an average rate of 6,298.58 per week and 905.98 per day. Approximately one account was created every 25 ledgers.

Finally the following is a list of some interesting articles & news stories from our partner site XRP Arcade:

The complete dataset which was used to generate the metrics above can be found here.

New XRP Intel Features

Come one, come all... be sure to checkout the newly deployed features to xrpintel!

  • New Deleted Accounts metric - tallies the number of accounts deleted in the reporting period
  • Expanded Transactions By Result metric to highlight / always tweet Critical Transactions. Right now this just includes tecINVARIANT_FAILED (the final XRPL failsafe ensuring ledger state stays sane & valid), though others may be added in the future
  • New ledger and transaction controls: Switch between formatted and raw JSON, expand and collapse all fields.

  • Specific reports now break down stats within that period, see metrics pertaining to days in a given month/week & hours within a given day

  • Charts now incorporate high level statistics including average, median, and standard deviation. Click on a stat to view on the chart.

  • Report metrics have been added to the API Documentation
  • Finally the xrp1ntel project has now been deprecated and is no longer available. Users should access the frontend via xrpintel.com and the API via api.xrpintel.com

Stay tuned for more exciting features coming soon!

XRP 2020 - Quarter 1

With recent events around the COVID-19 pandemic still ongoing, the beginning of this quarter seems like eons ago yet the XRP ledger has been in continuous operation during this entire period. While the network has seen a drop in activity from the plethora of transactions which tested the network last fall, the XRPL is still undergoing sustained usage with variable periods of activity on different fronts. One notable benchmark is the recent increase in account activity which is still higher than typical averages. The exact cause for this is still unknown but could indicate increased interest in XRP technologies

As with our yearly report, we start with the baseline metric of Ledgers Closed which as expected is fairly consistent with low variance. In the last 3 months, 2,051,380 total ledgers were closed with a weekly average of 157,850.25 ledgers and an daily average of 22,793.11 ledgers.

Click on an image to expand

The next metric computed is total transactions, which amounted to 90,949,838 last quarter, with an average rate of 1,010,553 transactions per day. 2020-01-06 was the week seeing the highest number of transactions: 11,599,975 (avg: 74.71 per ledger) with 2020-03-02 seeing the fewest, 6,979,812 total trasnactions (38.04 per ledger). The standard deviation from the daily average was 330,982.60 transactions, representing a 32.75% variance.

As far as fees burnt (recall every transaction on the XRPL consumes a small amount of XRP in fees), the network deducted 99,169.32 XRP overall (99,169,322,795 drops) with a weekly average of 8,264.11 XRP and an daily average of 1,134.93 XRP. The day of 2020-03-15 saw an anomalous transaction that needlessly burned a large amount of XRP (26,057.85!) in fees resulting in a large spike on total fees burnt on that day / week (always test your software before production!)

Breaking transactions down by type, the XRPL processed 10,553,789 total payments last quarter, with an average of 821,136.33 per week, the week of 2020-01-06 seeing the most payments (3,856,250) and the week of 202-01-20 seeing the least (354,051). The daily average was 11,5975.70 transactions, with a standard deviation of 194,099.26 payments per day or 167.36%. The network saw 62,027,963 total offers, with the week of 2020-01-06 corresponding to the most (5,784,260) and the week of 2020-02-10 having the least (4,166,357)

Some payment/offer details:

  • The total XRP payment volume was: 27,272,544.16 XRP
  • The total USD payment volume was: $21,427,464,531,827.992 this included a single transaction of ~21T USD not backed by actual currency (see this for more info)
  • The total BTC payment volume was: 1,090,424,710.72
  • Payments currencies:

    XRP, USD, CNY, ZAR, CNT, ZEC, XCN, AUD, BTC, UPC, UPY, QAU, WCN, REP, ZCN, UPO, UPA, UPD, XLM, EUR, ETH, BCH, ETC, GCB, ULT, JPY, LTC, UPH, CCK, DSH, UPU, UPK, UPE, ALV, YCN, TOS, SSC, HGT, DOG, STR, RJP, RPL, MFS, BTR, CAD, UCD, MYN, ADA, WAR, OPT, SPD, DKS, EMX, SOL, DKC, BBB, FDB, MIN, RSC, XAU, MON, BKC, XNF, XMM, GBP, NZD, VTC, BRL, XAG, XPT, 534F4C4F00000000000000000000000000000000, CNC, ECT, DIC, ICE, INR, FCM, RBJ, XCC, DRP, KRW, RTS, JKC, BRC, RMB, CDT, LQD, LQB, ZNY, GDK, FDS, BCC, JED, XNV, XID, DCX, HKD, FMM, TTT, XPY, DAO, WBF, WWW, BBC, TTE
  • Currency pairs traded:

    XRP/CNY, CNY/XRP, XRP/USD, XRP/EUR, USD/XRP, XRP/XLM, XRP/BTC, EUR/XRP, DSH/XRP, XRP/ETC, BTC/XRP, USD/CNY, XRP/ETH, ULT/XRP, XRP/DSH, XRP/ULT, DSH/BTC, XRP/BCH, ULT/CNY, CNY/USD, CNY/ULT, USD/USD, XLM/XRP, CNY/CNY, BTC/DSH, BTC/BTC, USD/BTC, BTC/USD, BTC/ETH, DSH/EUR, ETH/XRP, XLM/CNY, DSH/USD, EUR/ETH, EUR/USD, CNY/XLM, JPY/USD, BTC/EUR, ETC/XRP, JPY/EUR, EUR/CNY, JPY/XRP, CNY/EUR, XRP/JPY, XRP/REP, ALV/XRP, EUR/BTC, BTR/XRP, BCH/XRP, MFS/XRP, USD/EUR, XAU/EUR, XAU/XRP, XRP/XAU, ETH/BTC, USD/MFS, CAD/ALV, XRP/RUB, UPC/XRP, UPO/XRP, UPK/XRP, XRP/SCZ, BTC/BCH, EUR/ETC, USD/BCH, UPU/XRP, BCH/EUR, EUR/REP, BTC/CNY, ETH/CNY, XRP/ALV, JPY/BTC, RUB/XRP, INR/XRP, ETH/USD, ETH/EUR, XRP/INR, EUR/DSH, XLM/BTC, USD/ETH, REP/XRP, CNY/BTC, CNY/ETH, BCH/USD, ULT/XLM, XRP/CAD, BTC/XLM, TOS/CNY, CNY/TOS, ALV/USD, JNG/XRP, USD/DSH, CAD/BTC, CAD/CNY, CAD/ETC, CAD/BCH, CAD/USD, CAD/XAU, CAD/STR, CAD/FMM, CAD/ETH, CAD/XRP, ETC/BCH, BTC/ETC, AUD/XRP, XRP/AUD, ETC/USD, HGT/USD, EUR/BCH, DSH/ETH, CNY/DSH, REP/ETH, KRW/XRP, USD/STR, USD/ETC, REP/EUR, XRP/KRW, XLM/ULT, XRP/LTC, LTC/XRP, ETH/DSH, LQD/XRP, XRP/XTL, XRP/LQD, BCH/ETH, XTL/XRP, RPL/XRP, XRP/FOO, EUR/XAU, MYN/XRP, ETC/EUR, CCK/USD, XRP/ILS, BCH/ETC, EOS/XRP, BCH/BTC, WAR/XRP, FMM/XRP, RSC/XRP, FMM/CNY, CNY/ETC, UCD/XRP, STR/XRP, UCD/USD, GBP/XRP, XNF/XRP, UCD/EUR, USD/ALV, CHF/XRP, ETH/REP, SCZ/XRP, JPY/JPY, USC/XRP, DSH/ETC, XRP/MFS, CDT/XRP, USD/UCD, CDT/USD, WWB/XRP, ADA/XRP, STR/XLM, USD/ULT, ULT/USD, CNY/XML, MXN/XRP, XRP/534F4C4F00000000000000000000000000000000, XMC/XRP, XKC/XRP, BRC/ALV, ALV/BRC, BRC/RMB, RMB/BRC, 534F4C4F00000000000000000000000000000000/XRP, XRP/SOL, XRP/CDT, MXN/CDT, CDT/MXN, CDT/BTC, RMG/XRP, XRP/RMG, XRP/UCD, XRP/ADA, UCD/XLM, GCB/XRP, ETH/BCH, ETC/DSH, ULT/BTC, ETC/ETH, BRL/XRP, ABC/XRP, MON/XRP, XRP/WAR, XRP/ABC, CDT/XLM, SGD/XRP, SGD/USD, XRP/GCB, BTS/XRP, XAU/USD, XRP/ZPR, ZPR/XRP, XRP/SGD, USD/CCK, XRP/RPL, XRP/YYY, YYY/XRP, WBF/XRP, XRP/WBF, XRP/WWW, WWW/XRP, WBF/USD, XRP/STR, XRP/BBC, EUR/XLM, BBC/XRP, XRP/GBP, ETC/BTC, USD/534F4C4F00000000000000000000000000000000, TTE/XRP

The network saw 63,283 new accounts last quarter, at an average rate of 4,846.42 per week or 1 account every 32.42 ledgers. The week of 2020-01-06 saw the most (6,738) and the week of 2020-01-20 saw the fewest (3,256).

Finally the following is a list of some interesting articles & news stories from our partner site XRP Arcade:

The complete dataset which was used to generate the metrics above can be found here.

XRPL - On IOUs

A topic that we often get asked about is the quantity & quality of non-native currencies, also known as IOUs moving across the XRP Ledger. The XRPL supports sending and receiving any quantifiable asset (fiat currencies such as USD & EUR, crypto-currencies such as BTC & ETH, physical assets such as gold & silver, and pretty much anything else) across the network so long as there is an institution known as a gateway or a custodian backing that asset. It is the responsibility of the custodian to manage the real world assets which back the on-ledger IOUs and to provide the services used to issue and redeem those tokens, exchanging the digital value for physical.

xrp1ntel is known to report a wide variety of currencies being sent across the ledger. Last month alone, 21T USD, 512M BTC, 100B XLM, and much more was moved across the network. Obviously not all of this currency is backed by actual real-world assets (in the case of USD, we know for a fact that the 21 Trillion was issued / transferred to prove this point) and unless the issuer is a known/reputable institution is it hard to determine the legitimacy of these funds. That being said, for all practical purposes and from an operational perspective this doesn't matter a whole lot as we will discuss below.

The process of issuing an asset on the XRPL, whether fiat currency, an external crypto currency, or a new token allogther, transpires in the exact same manner. A client account extends a Trust Line to the issuing account for the maximum amount of currency which they trust the gateway to manage for them. In the case of real world assets such as USD or BTC, the client would then send the amount they would like to withdraw on the XRPL to the institution via the traditional payment network, and then invoke the mechanism requesting the withdrawl on-ledger. In the case of tokens solely issued on the XRPL, with no corresponding off-ledger backing, the first deposit step is replaced with whichever signup / on-boarding process the gateway requires, perhaps a new account being created, or an authorization process validating the user is part of some other network. After this point the process is exactly the same, the user specifies their XRP account address where they would like the funds to be issued to.

The onus of trust is always held by the client, it is up to each individual user to only extend trust to the institutions which they know will honour IOUs for off-ledger issuances when it comes time to redeem them and will honour the scarcity of the tokens in accordance to the stated issuance/governance policy. If this trust is misplaced, and the gateway is shown to be misallocating IOUs, the consequences will not be systematic, and the ramifications will be limited to those accounts that extended trust to the unreputable gateway.

Now with the context being established, lets explore some specifics of why it's important to not cast judgements either way pertaining to IOUs unless factual information is explicitly known:

  • Unless the issuer account explicitly states what their IOUs are, we can only assume they represent well known currencies. Perhaps BTC doesn't refer to Bitcoin but rather Bolivian Transfer Coin or perhaps USD doesn't refer to the United States Dollar but rather Universal Service Denomination. There are no guarantees and we don't know unless expressely stated.
  • Until we have more advanced tooling, metrics pertaining to tracking transferred tokens is cumulative. Lets say Alice Sent Bob, 5 BTC and then Bob sent that same 5 BTC back to Alice or to another user, the analytics will register this as 10BTC being transferred. While both metrics are valuable (discrete and cumulative values), the former will require much more advanced and resource-intensive state tracking than is currently available (Dev Null Productions is working on this!)
  • Assuming real-world IOUs, such as for BTC, is backed, the transfer of currency on the XRP ledger has the same effect as the transfer of currency on the BTC network, namely the value is being moved from one account to another (with the additional benefit that the former network is faster and cheaper than the later). "IOU" is meaningless in this context as the end result is the same. The same principle can be applied to fiat currencies which by large exist solely as digital representations in modern banking networks (the additional benefit to using XRPL in this case is the decentralization and transparency that it affords)
  • Backed or unbacked transactions look exactly the same on the XRPL. If the BTC being transferred is backed by actual Bitcoin or it is not, the XRPL transaction would manifest in the exact same manner. It is important to not lose sight of the forest for the trees.
  • Finally until proven otherwise, we shouldn't assume that transactions are not legitimate. Why not give the network the benefit of the doubt?

We hope this clears up some misconceptions pertaining to IOUs & tokens and clarifies our stance on representing them the way we do. We are in the process of expanding our metrics to provide additional intelligence pertaining to issuances & transfers from known/reputable institutions but this is one of many items on the backlog and we don't have a delivery date for this feature at the current time. In the end Dev Null Productions is committed to providing high-quality, factual intelligence and metrics to our clients and the XRP Community, and are eager to continue doing so in the years & decades ahead.

Until next time... Keep Zerping!

XRP in 2019

Last month XRP Community member and author of XRPArcade.com, LeoHadjiloizou contacted us indicating that he was writing a yearly summary of the XRP ecosystem in 2019 and was looking for some data pertaining to on-ledger activity. Given that this is our area of expertise we immediately jumped to the call and started looking into what would be required to compile such data. Unfortunately due to the timing of the development and deployment of our analytics system last year, we were missing the first few months of ledger data which had to be synced and benchmarked before the final report could be compiled. We setup a system locally to do this and a week later we were ready to go!

To start off, the baseline metric our analytics engine provides is Ledgers Closed which is fairly consistent and with low variance, given the continuous 2-4 second consensus time enforced by the network. In the past year 8,339,126 total ledgers were closed with a monthly average of 694,927.17 ledgers and weekly average of 159,915.02 ledgers. The standard deviation from the monthly average was 23,077.53 ledgers, representing a 3% variance.

Click on an image to expand

The next metric computed is total transactions, which amounted to 352,039,969 last year, with an average TX rate of 42.68 transactions per ledger. November was the month seeing the highest number of transactions: 63,227,755 (avg: 95.79 per ledger) with December coming in at a close second: 55,662,502 (avg: 81.88 per ledger). Followers of our twitter may recall our reporting on a plethora of questionable transactions going through the network last November, many similar in nature, consisting of BTC micropayments from an unknown issuer being sent back and forth between a set of accounts. February saw the fewest total transactions, 14,556,183 while March saw the smallest average transaction rate, 20.29 per ledger.

Related to transactions are fees, which the network enforces on a per-tx basis. Fees more or less aligned with transaction patterns with the exception of July which saw an anomalous spike, most likely due to a misconfigured client on the network. Overall 601,755.70 XRP (601,755,695,276 drops) was consumed in fees with a monthly average of 50,146.30 XRP and a weekly average of 11,537.63 XRP.

Breaking transactions down by type, the XRPL processed 68,216,082 total payments last year, with an average of 5,684,673.5 per month. The number of payments in November (34,103,937) dwarfed the previous months combined (17,023,428) by a factor of 100%. There was less variance in the number of offers created by month (total: 209,979,957), the standard deviation being: 7,447,452.46, or 3%. March saw the fewest offers created (8,061,435) with December having the most (29,537,933) and July being a close second (27,313,359).

The network saw a plethora of currencies go through it, including all the major fiat and digital ones. The total XRP payment volume was 456,718,135,629.3340. Large anomalous transactions resulted in spikes in the USD and CNY currencies in July and February respectively. Consistent payments in AUD, JPY, BTC, ETH, and XLM were present on the network throughout the year.

Offers on the other hand were dominated by the XRP/CNY and CNY/XRP pairs, whose volumes (94,382,927 and 86,523,240) dwarfed the next largest XRP/USD (8,156,685) and USD/XRP (2,874,124) by several orders of magnitude. Crypto/crypto and fiat/crypto pairings seemed to dominate the order books to a larger degree than fiat/fiat.

Finally we have accounts created which saw a spike last summer in the May & June timeframe, each month seeing approx 80K new accounts, a rate of 1 account every 10 ledgers. September saw the fewest new accounts, merely 13,927, a rate of 1 account every 50 ledgers. In total 408,872 new accounts were created last year, at an average rate of 0.049 accounts per ledger, or 1 account every 20.4 ledgers.

The complete yearly dataset can be found here. You can also see various metrics and benchmarks on the XRPArcade 2019 Yearly Report (under XRP Intelligence). Going forward be sure to look for consistent XRP data and stats coming from Dev Null Productions as well as new metrics and an expanded and optimized reporting system (for quicker and better reports). Keep Zerping!

NYC/XRP Meetup - Seeing 20/20

This past Tuesday, January 28th, the NYC/XRP Community hosted our 4th meetup, titled "Seeing 20/20" at the Lair East coworking space in SOHO Manhattan, NYC. The group, formed by a consortium of XRP Community members last summer, has hosted a series of meetups on a bi-monthly basis in a variety of formats, ranging from socials at local bars and restaurants, to tech talks, to group discussions and debates. The driving philosophy behind the group is to provide a resource for the local XRP community (both in NYC and in the greater tri-state region) to network, learn from each other, and grow together. While online communication channels such as Twitter and Telegram are great resources to stay in touch with our friends and colleagues world wide, it's not until we meet each other face to face and shake each others hands, that the true social bonding occurs and the true community is formed.

It was established after the last meetup in November that we wanted to put in the organiziational effort to make this as substantial as possible, as in recent months XRP has been gaining traction for international remittances and is being more and more recognized on the global finance scene. I'm extremely happy to report that the event was a monumental success, we assembled a great panel of speakers to discuss all things XRP and Blockchain, had an amazing turnout, a 3-round raffle (with the prizes being 250, 500, and 1000 XRP incrementally), and had a world-class buffet and beverage spread for all to enjoy. Guests of honour included many influencers from the crypto and XRP communities as well as prominant Ripple Labs directors and employees.

Lair East turned out to be the perfect venue to host the event, the setup was ideal and our hosts were extremely gracious and accomodating. Through use of some nifty technology we were able to livestream the event in 3D so that viewers were able to see all the action from all angles. The video can be viewed via Facebook, and is also available via youtube as the 3D player doesn't work on all systems:

Finally we have to recognize the individuals who made this event happen. While this is not a comprehensive list, these individuals went above and beyond to drive the success of this event and without their hard work and dedication it would have not been possible. So without further adieu I'd like to recognize:

Much gratitude goes to the individuals above as well as to all the community members who have supported the group on our journey so far.

And that's it for now! Be sure to stay tuned for future events (join the meetup to automatically get notified when they are scheduled) including our next meetup in March. Hope to see you all there!

VueJS Plugin Development Guide

In this guide we will explore how to create a new VueJS plugin from scratch. While creating a new standalone vuejs project is fairly straightforward (1. install vuejs 2. vue create <project_name> 3. yarn serve), creating a reusable plugin that is able to be incorporated into any VueJS project in a generic way is a more complicated process. Furthermore due to the novelty of the entire nodejs and vuejs ecosystem, there is a plethora of documentation specific to different steps of the process scattered across the web. This guide aims to provide a unified tutorial on how to create a plugin from scratch.

Note: We will be taking the most straightforward process to accomplish this, while there may be shortcuts, utilities to assist with different stages, and some steps may change over time, this guide should provide a concise resource of how to create and use a VueJS plugin.

Terminology:

Before we begin, here are some terms that developers will need to know:

  • JavaScript: eg JS, the programming language which we will be developing in
  • vuejs: A popular JS framework for creating web-based user interfaces
  • npm: The node package manager, a framework and set of utilities used to package and upload/download reusable bundles of javascript code (known as 'packages')
  • yarn: Another package manager for javascript with a builtin command specification and execution system. Uses the npm package registry on the backend (thus all packages uploaded to the npm repository are available to yarn for installation & inclusion)

Additional Terms:

Some additional terms which are good to know though not techincally needed:

  • nodejs: the JS runtime environment that executes JS code on the local machine
  • ECMAScript: eg ES, a standardization of syntax for languages such as Javascript. Comes in two primary variants ES5 and ES6. ES6 is an improvement on ES5 but is incompatible and most major browsers do not support it. ES6 has been superseded by more recent versions but those are compatible with ES6.
  • babel: A transpiler (source-to-source compiler) that converts newer version of ES (ES6+) to ES5 for browser compatability.
  • webpack: The underlying bundler which determines dependencies amongst your JS components and assembles them together into a single/isolated/importable module.
  • rollup: Another JS module bundler with a similar feature set to webpack but different implementation & tradeoffs
  • commonjs and AMD: Older JS encapsulation systems used before modules were standardized in ES6. Developers no longer need to concern themselves with these technologies.

Project Layout:

To begin, create a new directory for the plugin you would like to create. As a standard, it is good practice to prefix vuejs plugins with the vue- moniker. So if we wanted to create a 'nyan-cat' plugin, we would start byrunning:

$ mkdir vue-nyan-cat

Inside this directory, create some subdirs which will be used to encapsulate standard vuejs constructs and build artifcats:

$ cd vue-nyan-cat
$ mkdir dist examples src src/assets

package.json:

Create a package.json file, which yarn will you will use to specify dependencies and commands for yarn to execute:

{
  "name": "vue-nyan-cat",
  "version": "0.0.2",
  "description": "Renders the Nyan Cat in a VueJS based interface",
  "keywords": [
    "vuejs",
    "plugin",
    "nyan cat"
  ],
  "main": "dist/vue-nyan-cat.common.js",
  "license": "MIT",
  "author": "Mo Morsi <devnullproductions@gmail.com>",
  "repository": "github:DevNullProd/vue-nyan-cat",
  "scripts": {
    "serve": "vue-cli-service serve examples/main.js",
    "build": "vue-cli-service build --target lib src/nyan-cat.vue"
  },
  "dependencies": {},
  "devDependencies": {
    "@vue/cli-service": "^4.1.1",
    "vue": "^2.6.11",
    "vue-template-compiler": "^2.6.11"
  }
}

package.json explained:

Lets explore each of these sections one at a time.

To start we specify package metadata. This includes:

  • name: The unique name of your plugin
  • version: The current version of your plugin, make sure to increase appropriately this on every release
  • description: A human-friendly textual description of your plugin
  • keywords: Phrases to associate with your plugin to make it easy to lookup when uploaded to the npm package repository (more on this later)
  • main: The module output by the build system which will be loaded when a developer imports your plugin into their project. Note this module just constitutes the javascript code which is included in your plugin, the developer using it may also have to include the stylesheets (more on this later)
  • license: The legal license which you are releasing your plugin under
  • author: The developer/company which you are referencing as the author of the plugin
  • repository: The location where the plugin source code can be found
{
  "name": "vue-nyan-cat",
  "version": "0.0.2",
  "description": "Renders the Nyan Cat in a VueJS based interface",
  "keywords": [
    "vuejs",
    "plugin",
    "nyan cat"
  ],
  "main": "dist/vue-nyan-cat.common.js",
  "license": "MIT",
  "author": "Mo Morsi <devnullproductions@gmail.com>",
  "repository": "github:DevNullProd/vue-nyan-cat",

Next we define scripts, or command that will be accessible via invocation with yarn, eg. yarn run example which can be abbreviated to yarn example.

Here we define two commands:

  • serve which provides access to the plugin example it via a built-in webserver. Using this you can view the plugin locally by opening a web-brower and pointing it at the provided url (more on this below)
  • build which builds our package into a format which you can upload to the npm repository for subsequent download (by yourself and others, more below)
  "scripts": {
    "serve": "vue-cli-service serve examples/main.js",
    "build": "vue-cli-service build --target lib src/nyan-cat.vue"
  },

As you can see above, configuration options are specified for both the poi and bili commands, which may be tweaked if desired

Finally we specify dependencies and devDependencies which our component requires to perform properly. Dependencies are need to execute your plugin in production and are pulled in when it is downloaded/installed from npm. devDependencies are only used during the development phase, in our case the VueJS dependencies we need to run the project commands.

  "dependencies": {},
  "devDependencies": {
    "@vue/cli-service": "^4.1.1",
    "vue": "^2.6.11",
    "vue-template-compiler": "^2.6.11"
  }
}

Plugin Implementation:

Now lets get to actually building the plugin! We won't go into too much detail as to how VueJS works here, there are plenty of docs on how to develop VueJS functionality on the web (including the excellent developer documentation), but we will discuss a few critical components:

  • src/nyan-cat.vue - the main module which will define the top level component constituting our plugin
  • src/index.js - defines the install target which will be executed when our plugin is loaded into a VueJS project
  • examples/index.js - the main entry point for the example target, recall this was referenced in the poi script in package.json

src/nyan-cat.vue

The main implementation of our plugin... do your magic here!

<template>
  <div id="nyan-cat">
    <img src="https://raw.githubusercontent.com/DevNullProd/vue-nyan-cat/master/src/assets/nyan-cat.gif" />
  </div>
</template>

<script>
export default {
  name: 'NyanCat'
}
</script>

<style scoped>
#nyan-cat{
  display: inline-block;
  padding: 10px;
  border: 1px solid black;
  border-radius: 5px;
}
</style>

Because we are referencing a static image (nyan-cat.gif) it must be downloaded and placed in the src/assets directory. You may get it from here:

src/index.js

Recall this defines install which will be executed when we import & use our plugin in a larger VueJS project.

import NyanCat from './nyan-cat.vue'

export default {
  install : function(vue, opts){
    vue.component('NyanCat', NyanCat)
  }
}

examples/index.js

This replicates the 'main' module of a larger VueJS project and will be used for demonstation / test purposes

import Vue from 'vue'
import App from './App.vue';

import NyanCat from '../src/index.js'

Vue.use(NyanCat)

new Vue({
  el: '#app',
  render(h){ return h(App) }
})

examples/App.vue

The top level component in our example project where we actually use our plugin in the UI

<template>
  <NyanCat />
</template>

<script>
export default{
}
</script>

examples/index.html

Defines the static web page in which the top level component in our example project will be mounted

<!DOCTYPE html>
<html>
<body>
  <div id="app"></div>
</body>
</html>

Test it!

And that's it! To test our plugin by running the example, do the following:

Install dependencies

$ yarn install

Build and run the example

$ yarn serve

Finally open a web browser and point it a http://localhost:4000/vue-nyan-cat/ to see your plugin!

Round out your plugin

In general it is good practice to include a README.md file, explaining how to install, import, and use your plugin, and a LICENSE file containing the full text of the license which you are releasing your package under (the same one as that referenced in package.json above).

Build it!

$ yarn build

This will place your plugin output in the dist directory. Now you are ready to ship it!

Ship it!

In order for others to access your plugin you will have to upload it to NPM. First sign up for a new account. Once you have done so, login via the following command:

$ npm login

Enter the credentials you supplied when creating your account. Finally upload it with:

$ npm publish

The package will now be on NPM! You may view it at: https://www.npmjs.com/package/vue-nyan-cat.

Use it!

To use our new plugin in a larger VueJS project, first cd to the project dir and install it with yarn:

$ yarn add vue-nyan-cat
Finally import the plugin into your component and use:
<template>
  <div id="app">
    <NyanCat />
  </div>
</template>

<script>
import NyanCat from 'vue-nyan-cat'
import 'vue-nyan-cat/dist/vue-nyan-cat.css'

export default {
  name: 'app',
  components: {
    NyanCat
  }
}
</script>

Fin

You can see the complete example above on github along with other examples of Vue components under the DevNullProd organization.

DNP - 2019 Retrospective

Can you believe it's almost December already! Lets look at many of the great events and happenings that we participated in this past year.

XRP Community Meetup - Amersfoort

Earlier last spring Dev Null took a trip to the scenic country of the Netherlands to attend the XRP Community Meetup in Amersfoort, hosted by none other than Wieste of XRPL Labs and Tom Kuster. Denmark is a beautiful country, full of history and culture, especially in the financial world, as it was one of the original homes of the modern banking industry. The meetup was a great experience as it faciliated an opportunity to put faces to all the Twitter handles and form bonds which will last a lifetime.

Development Releases - XRBP, Wipple, xrp1ntel

Spring of this year also saw a flury of releases of XRBP, our Open Source interface to the XRPL, written in Ruby. Early releases included base level support for the XRP websocket API as well as related web based resources (the DataV2 API, exchange data, etc). Subsequent releases incorporated functionality allowing the client to:

  • Crawl / traverse the peer-to-peer network of XRPL nodes
  • Directly parse the XRP binary database (the nodestore)
  • Generate node and account keys pairs and addresses
  • Access the sqlite database embedded in XRPL instances
  • And much more!

Additionally, the intial prototype version of our analytics engine, dubbed Wipple (originally stemming from the combination of 'Wallet' and 'Ripple') saw much growth at the beginning of the year up to the summer. Most of this early development was spent spec'ing out and prototyping many features and ideas that we were brainstorming. Over the summer this product underwent a rewrite and redesign, and morphed into our new flagship analytics product xrp1ntel which is under active development to this day.

The evolution of the XRP Analytics Engine

Dev Null Prod relocates & the beginning of NYC/XRP

This past summer also saw the relocation of Dev Null Productions from Upstate NY to NYC. While we will always have a presence upstate and it will always have a special place in our heart, this was decision was executed so as to maximize growth of the business and network, and we have been having so much fun that we haven't looked back!

Part of the fun has included organizing and running the NYC/XRP meetup, consisting of a group of XRP enthusiasts in the tri-state area. Meetups are held at an interval of every other month and consists of a variety of social gatherings and tech talks used to bring the community together for networking and growth. To this date the meetups we've held included

  • July - Our first community social / meet & greet
  • September - Our first tech talk held in Chelsea, the presentation of the night was titled XRP - An Intro
  • November - An informal dinner which we held at a great steakhouse in midtown
The next meetup will be held in January, and most likely will be in a tech talk format again. Be sure to join the meetup group to stay in the loop!

Conference Galore

The past year has seen our attendance at several major conferences. From the 1st and 2nd SFBW conferences in San Francisco, CA, to Money 20/20 in Las Vegas, NV, to the AWS Summit in our new home city, we never missed an opportunity to promote XRP technology and #XRPCommunity efforts to build the ecosystem. We're big on conference attendance, not only are they great ways to meet a spectrum of professionals from many industries but they are excellent opportunities to quickly get our startup's brand infront of alot of organizations, both small and large. We're planning and are very eager to attend DLTCONLA (Los Angeles, CA) with several members from the NYC/XRP community this spring and will be sure to continue attending the hottest events as we hear about them!

Rippled Contributions

One final endeavor that we'd like to point out is our continued involvement in the development of the core rippled codebase driving the XRPL Blockchain. Serving dual purposes, firstly to contribute to and support the growth of the ecosystem, as well as for us to stay in the loop at the ground level (there is no better way to do that than to be working on the core repo!), we've submitted several patches/pull-requests to the codebase which have been subsequently merged / integrated into the core product (props to the Ripple Labs engineering team who are top notch and very friendly/open to development synergy). These features include:

  • Code cleanups & fixes, addressing issues as we encountered them during our source code analysis
  • Refactoring of the CMake-based build system, to faciliate modularization, compartmentalization, and easier-understanding by new contributors
  • Implementation of the consensus stream, allowing the user to subscribe to real-time updates of consensus state

Fin

And that's all for now! This past year has seen momentous growth both in terms of the #XRPCommunity and Dev Null Productions, we can't wait to continue driving things forward and seeing the ecosystem evolve next year! Until next time... Happy Zerping!

XRBP - The Ultimate XRP / Ruby Interface

Dev Null Productions is pleased to announce the general availability of XRBP a library aimed at providing an accessible, fault-tolerant interface to the XRP ledger. XRBP allows the developer to read and write data to/from the XRP network in real time, synchronizing ledger data including accounts, transactions, objects, and more. Data is presented via both synchronous and asynchronous mechanisms with multiple-connection load balancing and fault tolerance baked in behind the scenes.

But some code is worth a 1000 words! The following allows you to pull server info pertaining to the instance of rippled you are connected to:

require 'xrbp'

ws = XRBP::WebSocket::Connection.new "wss://s1.ripple.com:443"
ws.add_plugin :autoconnect, :command_dispatcher

ws.cmd XRBP::WebSocket::Cmds::ServerInfo.new

Above we see

  • the XRBP library is included
  • a new websocket connection to s1.ripple.com is established
  • and the ServerInfo command is dispatched and the results printed

To facilitate fully-customizable and configurable applications XRBP incorporates a pluggable architecture where modules customizing the request/response workflow and validating/transforming result sets may be registed with connection objects. As of the current date, plugins exist to:

  • Automatically timeout inactive connections and reestablish the link
  • Automatically retry failed requests (with configurable max tries and timeout)
  • Allow the user to register custom data parsers to transform received data
  • Paginate results behind the scenes so large data sets (transactions, account objects, etc) can all be seemlessly retrieved and aggregated before the results are returned
  • Dispatch and validate XRP specific commands, extracting specific data out of the result set for client consumption

Furthemore XRBP facilitates fault tolerant communications by implementing serveral multi-connection strategies behind these scenes. Each strategy manages an internal pool of connections and cycles through them according to different criteria.

To use multiple XRP servers in a 'round-robin' manner where subsequent connections will always be delegated to the next connection in the list:

ws = XRBP::WebSocket::RoundRobin.new "wss://s1.ripple.com:443",
                                     "wss://s2.ripple.com:443"

ws.add_plugin :command_dispatcher
ws.connect

puts ws.cmd(XRBP::WebSocket::Cmds::AccountInfo.new("rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"))
puts ws.cmd(XRBP::WebSocket::Cmds::AccountInfo.new("rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"))

In the above example we will retrieve info pertaining to the first account (rvYAf...) from s1.ripple.com and the second account (rhub8...) from s2.ripple.com. With the RoundRobin strategy, once all connections are used, we will cycle back to the first, in this case the next request will be issued to s1.ripple.com.

To automatically leverage backup servers if a request fails, we can use the Prioritized strategy:

ws = XRBP::WebSocket::Prioritized.new "wss://s1.ripple.com:443",
                                      "wss://s2.ripple.com:443"

ws.add_plugin :command_dispatcher, :result_parser
ws.parse_results { |res|
  JSON.parse(res)["result"]["ledger"]
}
ws.connect

puts ws.cmd(XRBP::WebSocket::Cmds::Ledger.new(28327070))

In this example we see that we establish a Prioritized connection set, and register a plugin to automatically parse data retrieved from the server. If we are not able to retrieve a valid ledger, the parser will throw an error and we will automaticlaly try the next connection behind the scenes. Thus if we query for a ledger which has been deleted from our primary rippled server, we can fall back to a full-history node.

This is just the icing on the cake as far as multi-connection strategies, there are several more included in the public XRBP API and developing custom strategies is as simple as inheriting XRBP::WebSocket::MultiConnection and defining next_connection.

XRBP can do much more ontop of all this. We can sync validators, gateways, etc from the DataV2 API, sync market quotes from exchanges, crawl the network and much more!

Listing Validators

connection = XRBP::WebClient::Connection.new
XRBP::Model::Validator.all(:connection => connection)
                      .each do |v|
  puts v
end

Crawling Nodes

connection = XRBP::WebClient::Connection.new
connection.timeout = 3

connection.on :peer do |node, peer|
  puts "#{node.url} peer: #{peer.url}"
end

XRBP::Model::Node.crawl("wss://s1.ripple.com:51235",
                        :connection => connection)

See project documentation and examples/ for complete details. And make sure to stay tuned there are alot more great features coming!