stampery

Stampery

NodeJS client library for Stampery API, the blockchain-powered, industrial-scale certification platform.

Seamlessly integrate industrial-scale data certification and timestamping into your own NodeJS apps. The Stampery API adds a layer of transparency, attribution, accountability and auditability to your applications by connecting them to Stampery's infinitely scalable Blockchain Timestamping Architecture.

Background

The Stampery API allows you to prove the existence, integrity and ownership of all your data by anchoring (embedding) unique identifiers (hashes) of your files and datasets into the Ethereum and Bitcoin blockchains.

The timestamps and proofs generated by this API are independently verifiable at no cost by anyone in the world, and they will be valid forever—even if Stampery disappeared.

Each proof connects every single stamped hash to a transaction contained in the next Ethereum and Bitcoin block. This means that Ethereum receipts take ~30 seconds in average to be generated, while Bitcoin ones take ~5 minutes.

Our BTA technology aggregates all hashes received between one transaction and the next one by putting them inside a Merkle tree and then broadcasting the result of the aggregation—which we call the Merkle root. This allows us to include millions of hashes in every transaction at a fraction of the cost and without loosing the immutabiity properties of public blockchains.

The proofs themselves contain only a few auxiliar hashes that when concurrently hashed together with your stamped hash, allow anyone to reconstruct the state of the Merkle tree at the very exact point in time when the stamping took place.

As all the hash functions involved in the aggregation are one-way functions, there is no way to counterfeit a proof that would connect a certain hash to any past transaction. Likewise, it is impossible to make up a fake proof that would be valid for a tampered file.

You can read more about BTA and blockchain anchoring in our whitepaper.

Glossary

• The process of anchoring one hash into a blockchain is called stamping.
• One embeded hash is called a stamp.
• The stamping process will return one receipt for every blockchain being used.
• Each receipt contains all the necessary data for proving the existence and integrity of the stamped data.
• The part of a receipt telling where to find the blockchain transaction is called anchor.
• Proving means demonstrating that a receipt is valid and therefore the file or dataset from which the hash was calculated existed by the time the stamp was made.
• Feel free to use stamp as a verb and say "I will stamp this document".

Installation

1. Install stampery into your project and add it as a dependency in your package.json:

npm install --save stampery

1. Go to the API dashboard, sign up, create a token for your application (or use the default one) and copy its user secret. It will resemble this:

14f1e553-325f-4549-ced6-6c5311b1a470

Usage

Basic setup

/**
* Import Stampery API for NodeJS
 */
const Stampery = require('stampery');

/**
* Please replace this dummy user secret with a real one.
* Sign up and get your own user secret at https://api-dashboard.stampery.com
 */
var stampery = new Stampery('14f1e553-325f-4549-ced6-6c5311b1a470');

Stamping workflow

/**
* Simple workflow for stamping a string.
* This will return all the data related to the stamp plus an estimation of the
* remaining time in seconds for the Ethereum and Bitcoin receipts to be ready
* for proving. Average ETA is ~30 seconds for ETH and ~5 minutes for BTC.
 */
var h = stampery.hash('the piano has been drinking ' + Math.random());
stampery.stamp(h, function(err, stamp) {
  if (err) {
    return console.error(err);
  }
  return console.log(stamp);
});

Retrieving and proving a stamp and its receipts

/**
* Example for retrieving the receipts for a certain stamp at any time
* afterwards. It also verifies if the proof is valid and prints the result.
 */
stampery.getById('5857d1629e7cba66c3ea20a8', function(err, res) {
  if (err) {
    return console.error(err);
  }
  console.log(res);
  if (res) {
    return console.log('Valid: ', stampery.prove(res.receipts));
  }
});

Retrieving all stamps related to a hash

/**
* Example for retrieving all the stamps and receipts related to a certain file
* hash at any time afterwards.
 */
stampery.getByHash('<put here the file hash>', function(err, res) {
  if (err) {
    return console.error(err);
  }
  return console.log(res);
});

Retrieving the whole stamp history

/**
* Example for retrieving all the receipts in your stamps history at any time
* afterwards. For the sake of responsiveness, it will return only the last 50
* stamps (page 0).
 */
stampery.getAll(function(err, res) {
  if (err) {
    return console.error(err);
  }
  return console.log(res);
});

/**
* Example for retrieving next 50 receipts from the stamps history.
* Increase the first argument to get page 0, 1, 2, 3 and so on.
* This example should return stamps numbers from 200 to 249.
 */
stampery.getAll(4, function(err, res) {
  if (err) {
    return console.error(err);
  }
  return console.log(res);
});

FAQ

Is there any privacy concern derived from using public blockchains?

No. Hashes are always calculated client-side, and only anonimous hashes go through our service and get eventually published. No one can know what you are actually stamping—not even us.

Can I choose which blockchain to use?

No. This API currently anchors your hashes into both the Ethereum and the Bitcoin blockchains for latency and redundancy reasons. In the future we may support other blockchains if they provide interesting features for anchoring.

Can I stamp the same hash twice?

Yes. You can stamp the same hash as many times as you want in order to link the hash to more than one block. Nevertheless, the most valuable stamp is always the oldest one when you aim to prove original ownership or existence of a file.

What is the effective timestamp for a stamp?

Every receipt contains a time field that tells the exact point in time in which the API received the hash. This trust-based, rather traditional timestamp is solely attested by Stampery.

For a decentralized, tamper-proof, censor-resistant, math-backed timestamp, the valid date you are looking for is the one that appears when you take the transaction ID from the anchor in each receipt and search it in a blockchain explorer.

Feedback

Ping us at [e-mail] and we will be more than happy to help you with your integration! 😃

License

Code released under the MIT license.

© 2015-2017 Stampery, Inc.