tim

    6.5.2 • Public • Published

    Trust in Motion (TiM)

    Build status

    TiM is Tradle's SDK that provides real-time messaging with an option for messages to be sealed on the blockchain. Mesages can be plain or structured messages. TiM is designed to work on mobiles, desktops and servers. Having one code base is important to minimize security reviews.

    TiM is designed to work with intermittent connections, common on mobile devices. For that it keeps an internal log of all actions and events, and resumes operations as soon as network connection is restored.

    TiM's operations are covered by a patent. The tatent is filed only for defensive purposes, so you are welcome to use it in your open source projects.

    this module is used by Tradle
    this npm module's name was graciously donated by Sean Robertson

    TiM provides a higher level API to a number of low level Tradle components. A UI is developed separately. Currently we focus on React Native based UI (on iOS, the Android version of TiM is in works), see the preview video and the screenshots.

    Prior to React Native, we developed the UI for Tim as a Chrome App, see this Identity verification video and a work completion video. And prior to that we developed a very cool node-webkit-based craigslist on-chain concept app on TiM, but it is very much behind now. We plan work on desktop version of TiM soon, let us know if you are interested in these environments and we will prioritize this work for you.

    TiM uses the following Tradle components:

    zlorp

    Zlorp is just the core chat module. It uses OTR for secure sessions (later will add support for Axolotl, used in TextSecure and Pond). Peer discovery today is done via bittorrent-dht. But DHT's regular announce messages leak IP/Port, so we will see if we can use BEP 44 to encrypt them. Zlorp provides UDP NAT traversal (firewall hole-punching), and a direct connection via rUDP (later via uTP). We plan to further investigate anonymous packet delivery, possibly via I2P (TOR does not support UDP).

    bitkeeper-js

    Bitkeeper module uses WebTorrent for storing and ensuring replication of arbitrary files. In Tradle, bitkeeper is used to store the original (encrypted) versions of on-chain objects (structured messages).

    chained-obj

    Chained-obj is object builder and parser. Currently uses multipart to store arbitrary JSON data + attachments. These objects are later encrypted and put on-chain.

    bitjoe-js (to be renamed to: chainwriter)

    A collection of requests that can be used to put an object "on chain": encrypt an object for its recipients, store/seed it from a bitkeeper node and put private links on blockchain.

    tradle-constants

    Wait for it...a bunch of constants

    tradle-utils

    A small set of crypto and torrent-related functions used by a number of Tradle components

    Identity

    Identity is wrapper around an OpenName-compatible Identity schema. Used for building/parsing/validating identity objects.

    kiki

    kiki Wrappers for DSA, EC, Bitcoin and other keys to provide a common API for signing/verifying/importing/exporting.

    chainloader

    Parses bitcoin transactions, attempts to process embedded links, loads intermediate files and original files from a bitkeeper node, decrypts and returns files and metadata. Implements stream.Transform.

    simple-wallet

    One-key common blockchain based wallet.

    tradle-tx-data

    For building/parsing bitcoin-transaction-embedded data

    tradle-verifier

    Plugin-based verifier for on-chain objects. Implements several default plugins:
    Signature Check
    Identity verification
    Previous Version verification

    Exports

    Datalog

    This module uses a datalog, a log-based database of experienced activity that you can write to and use to bootstrap your own databases from.

    Messaging API

    Details to follow

    Usage

    Identity Identifiers

    When you want to communicate with someone else on the network, you need to identify them uniquely. You can identify them by a fingerprint of one of their public keys, a public key string, or by their identity's root hash:

    // if this is the identity of your friend Bill:
    {
      "_t": "tradle.Identity",
      "pubkeys": [
        {
          "fingerprint": "mvDNdZFbCCmnAPCBmLY91LnfKWoMH39Q2c",
          "networkName": "testnet",
          "purpose": "payment",
          "type": "bitcoin",
          "value": "03a45ede4be12a812e6e2ef1650ecbd8900152b1c6e3fe47f427ee5d9323759fe3"
        }
      ]
    }
     
    // the following are equivalent identifiers for Bill:
    {
      fingerprint: 'mvDNdZFbCCmnAPCBmLY91LnfKWoMH39Q2c' 
    }
     
    {
      _r: 'whatever the infoHash of the above JSON object is'
    }

    Initialization

    var path = require('path')
    var levelup = require('levelup')
    var leveldown = require('leveldown') // or asyncstorage-down or whatever you're using
    var Blockchain = require('cb-blockr') // use tradle/cb-blockr fork
    var Identity = require('@tradle/identity').Identity
    var defaultKeySet = require('@tradle/identity').defaultKeySet
    var Keeper = require('@tradle/http-keeper')
    var Tim = require('tim')
     
    // Setup components:
    var networkName = 'testnet'
    var blockchain = new Blockchain(networkName)
    //   Create an identity or load an existing one (see tradle/identity readme):
    var jack = new Identity()
    var jackPrivKeys = defaultKeySet({ networkName: networkName })
    jackPrivKeys.forEach(jack.addKey, jack)
    //   to export private keys:    jackPrivKeys.forEach(k => k.exportPrivate())
    //   to export public identity: jack.toJSON()
     
    var myDir = path.join(process.env.HOME, 'myTradle')
    //   content-address storage for your encrypted messages
    var keeper = new Keeper({
      db: levelup(path.resolve(myDir, 'keeper'), { db: leveldown, valueEncoding: 'binary' }),
      fallbacks: ['http://tradle.io:25667']
    })
     
    // the API
    var tim = new Tim({
      pathPrefix: path.join(myDir, 'tim'), // for playing nice with other levelup-based storage
      leveldown: leveldown,
      networkName: networkName,
      identity: jack,
      keys: jackPrivKeys, 
      keeper: keeper,
      blockchain: blockchain,
      // optional
      syncInterval: 600000 // how often to bother cb-blockr
    })
     
    // define a _send function that will determine the transport to use
    // to deliver a message to a particular recipient
    tim._send = function (recipientRootHash, msg, recipientInfo) {
      // return a Promise that resolves when the message is delivered
      // e.g. tim2.receiveMsg(msg, { _r: recipientRootHash })
      // 
      // tradle has several network-adapters for message delivery that you can use here. 
      // They are all open source on Github:
      //   tradle/zlorp - pure p2p messaging with OTR over UDP
      //   tradle/http-client & tradle/http-server
      //   tradle/ws-client & tradle/ws-relay - OTR over websockets
      //   
      //   latest, but unstable:
      //   tradle/sendy, tradle/sendy-otr
      //     reliable delivery over network of choice. 
      //     websockets implementation: tradle/sendy-ws, tradle/sendy-ws-relay
    }
     
    tim.send({
      to: [{ fingerprint: 'one of their fingerprints' }],
      msg: { hey: 'ho' },
      deliver: true,  
      chain: false
    })
     

    Publishing your identity

    tim.publishMyIdentity()

    Sending messages

     
    tim.send({
      msg: Object|Buffer,
      // record message on chain
      chain: true,
      // send message p2p
      deliver: true,
      to: [
        identityIdentitifier // see Identity Identifiers
      ]
    })
     

    Sharing existing messages (via the blockchain)

     
    var constants = require('@tradle/constants')
    var curHash = '...' // the infoHash of the existing message, see tradle/utils `getStorageKeyFor`
    var shareOpts = {
      // record message on chain
      chain: true,
      // send message p2p
      deliver: true,
      to: [
        identityIdentitifier // see Identity Identifiers  
      ]
    }
     
    shareOpts[constants.CUR_HASH] = curHash
    tim.share(shareOpts)
     

    Publishing on chain

    Same as sending a message, but use tim.publish instead of tim.send

     
    tim.publish({
      msg: Object|Buffer,
      to: [
        identityIdentitifier // see Identity Identifiers
      ]
    })
     

    Messages

    var db = tim.messages() // read-only levelup instance
     
    // e.g.
    db.createValueStream()
      .on('data', function (err, msg) {
        // issue tim.lookupObject(msg) to get decrypted metadata and contents
      })

    Identities (loaded from chain)

    var db = tim.identities() // read-only levelup instance
     
    // e.g.
    db.createValueStream()
      .on('data', function (err, identityJSON) {
        // do something with "identity"
        // console.log('yo', identityJSON.name.firstName)
      })
     
    // additional convenience methods
    db.byRootHash(identityRootHash, callback)
    db.byFingerprint(fingerprint, callback)

    Events

    tim.on('ready', function () {...})

    Tim's ready to do stuff

    tim.on('chained', function (info) {...}

    An object was successfully put on chain1

    tim.on('unchained', function (info) {...}

    An object was read off chain1

    tim.on('message', function (info) {...}

    A message was received peer-to-peer1

    tim.on('sent', function (info) {...}

    A message was delivered1

    tim.on('resolved', function (info) {...}

    An object was both received peer-to-peer and read from the chain1

    1 Note: does NOT contain chained-object contents. Use tim.lookupObject(info) to obtain those.

    Install

    npm i tim

    DownloadsWeekly Downloads

    441

    Version

    6.5.2

    License

    GPLv3

    Last publish

    Collaborators

    • genevayngrib
    • pgmemk
    • tenaciousmv
    • spro