hybrix-jslib

This Javascript library can be used to connect software to leverage the capabilities of the hybrix platform. It serves two purposes: first to facilitate the logistics of interfacing with the hybrixd API, secondly to handle all client-side operations securely and privately. This ensures that keys required for transactions never leave the users device and communication happens over an encrypted channel.

Quick start

There are two flavours of the library: the web version to include in your webpage or front-end, and the node js version to include when you are building back-end software.

Here is a Hello World example of how to use hybrix-lib.js in your front-end. First include the library using script tags.

<html>
 <head>
  <script src='hybrix-lib.web.js'></script>
 </head>
 <body>
  <script>
   var hybrix = new Hybrix.Interface();
   hybrix.sequential(
    [
     {host:'https://api.hybrix.io/'}, 'addHost'                     //  Connect to host
    ],
    host => alert('Connected to '+ host),                           // Define action to execute on successfull completion
    error => alert('Oops, something went wrong: '+error)           // Define action to exectue when an error is encountered
   );
  </script>
 </body>
</html>

For nodejs projects:

const Hybrix = require('./hybrix-lib.nodejs.js');
const hybrix = new Hybrix.Interface();
hybrix.sequential(
  [
   {host:'https://api.hybrix.io/'}, 'addHost'                     //  Connect to host
  ],
  host => console.log('Connected to '+ host),                     // Define action to execute on successfull completion
  error => console.error('Oops, something went wrong: ' + error)  // Define action to exectue when an error is encountered
);

Or using npm:

Install the package using npm npm install hybrix-jslib

const Hybrix = require('hybrix-jslib');
const hybrix = new Hybrix.Interface();
hybrix.sequential(
  [
   {host:'https://api.hybrix.io/'}, 'addHost'                     //  Connect to host
  ],
  host => console.log('Connected to '+ host),                     // Define action to execute on successfull completion
  error => console.error('Oops, something went wrong: ' + error)  // Define action to exectue when an error is encountered
);

Callbacks

Each command is implemented as a member function of the Hybrix.Interface class. Adding a host can be done as follows.

hybrix.addHost({host:'https://www.example.com'});

Here only one parameter is passed but each member function has four parameters: data, onSuccess, onError and onProgress.

The first is used to pass parameter data to the function. The last three are callback functions. onSuccess is called once when the method has finished successfully. onError is called once when an error is encountered. onProgress is called whenever a progress update is available, passing a number between 0 and 1, and 1 upon completion.

To first add a host and then query for asset balance one could try the following:

hybrix.addHost({host:'https://www.example.com'});  // This is an asynchronous function. It can take some time to complete.
hybrix.rout({query: 'Query for asset balance'});   // Problem! This will try to request routing before the addition of the host is done.

This results in serious problems due to asynchronicity. One could use the callbacks to ensure the execution order.

hybrix.addHost({host:'https://www.example.com'},
  function(){
    hybrix.rout({query:'/asset/btc/balance/32FCGFdRGeho2HBeWQPaAYawJfPqHHvsCJ'});     //  This will now be called after the addition of the host is successfully completed.
  }
);

But adding more steps or error handling will end up with code that is both very hard to read and maintain. (This is sometimes dubbed callback hell.) To mitigate this the library comes equiped with a sequential and a parallel command to handle these asynchronious call flows. With an added bonus of handling the progress for combined commands as well.

hybrix.sequential([
{host: 'http://localhost:1111/'}, 'addHost',                   // Add and initialize the host
{query: '/asset/btc/balance/32FCGFdRGeho2HBeWQPaAYawJfPqHHvsCJ'}, 'rout'  // Query for asset balance
],
onSuccess,                                                      // Define action to execute on successfull completion
onError,                                                        // Define action to execute when an error is encountered
onProgress                                                      // Define action to execute whenever there is a progress update
);

hybrix.sequential([
{host: 'http://localhost:1111/'}, 'addHost',                   // Add and initialize the host
{query: '/asset/btc/balance/32FCGFdRGeho2HBeWQPaAYawJfPqHHvsCJ'}, 'rout'  // Query for asset balance
],
onSuccess,                                                      // Define action to execute on successfull completion
onError,                                                        // Define action to execute when an error is encountered
onProgress                                                      // Define action to execute whenever there is a progress update
);

For even more complex behaviour we advice you to implement your own favourite flavour method of handling the call flow, be it promises, streams, or async, etc.

Live example

Progress

Result

...

Reference

No results. Change your search filter or reset the filter.

AssetManagement

addAsset{symbol, [seed], [keys], [privateKey], [clientModuleCodeBlob], [check=true], [offset=0], [host], [channel], [includeBaseAssets=true]} Add an asset (crypto currency or token) to the session.

Add an asset (crypto currency or token) to the session.

Name	Type	Description
data	Object
data.symbol	string	The symbol of the asset
data.seed	string	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Pass a custom seed to generate the asset keys
data.keys	string	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Pass a keypair
data.privateKey	string	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Pass a privateKey
data.clientModuleCodeBlob	string	[Optional] A string containing the client module code blob.
data.check	Boolean	[Optional, default = true] Whether to check if the provided clientModuleCodeBlob matches the remote version
data.offset	string	[Optional, default = 0] The deterministic offset
data.host	string	[Optional] The host used for the calls.
data.channel	string	[Optional] The channel used for the calls. 'y' for encryped, 'z' for encryped and compresses;
data.includeBaseAssets	string	[Optional, default = true] Add the base asset too. (Main chain for token)

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'addAsset'
    ]
      , onSuccess
      , onError
      , onProgress
    );

addUnifiedAsset{symbol, [offset=0], name, symbols, [info], [host], [channel]} Add a unified asset TODO

Add a unified asset TODO

Name	Type	Description
data	Object
data.symbol	string	The symbol of the asset
data.offset	number	[Optional, default = 0] The deterministic offset
data.name	string	The name of the asset
data.symbols	string	The symbol of the asset
data.info	string	[Optional] The info of the asset
data.host	string	[Optional] The host used for the calls.
data.channel	string	[Optional] The channel used for the calls. 'y' for encryped, 'z' for encryped and compresses;

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'xmpl', symbols:{btc:1,eth:1}}, 'addUnifiedAsset',
    {symbol: 'xmpl'}, 'refreshAsset'
    ]
      , onSuccess
      , onError
      , onProgress
    );

asset{[symbol], [offset=0], [host], [channel]} Get detailed information about assets

Get detailed information about assets

Name	Type	Description
data	Object	An array of symbols. For example: ['eth','btc','nxt']
data.symbol	Object	[Optional] An array of symbols. For example: ['eth','btc','nxt']
data.offset	integer	[Optional, default = 0] The deterministic offset
data.host	string	[Optional] The host used for the calls.
data.channel	string	[Optional] The channel used for the calls. 'y' for encryped, 'z' for encryped and compresses;

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'asset'
    ]
      , onSuccess
      , onError
      , onProgress
    );

form{amount, factor} Format a number according to its factor

Format a number according to its factor

Name	Type	Description
data	Object
data.amount	string	the amount to format
data.factor	string	the number of decimals

    hybrix.sequential([
      {data:'123.0', factor: 4}, 'form' // returns '123.0000'
    ]
      , onSuccess
      , onError
      , onProgress
    );

getAddress{symbol, [offset=0]} Get the address associated to a specific asset for current session.

Get the address associated to a specific asset for current session.

Name	Type	Description
data	Object
data.symbol	string	The asset symbol.
data.offset	integer	[Optional, default = 0] The deterministic offset

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'getAddress'
    ]
      , onSuccess
      , onError
      , onProgress
    );

getBalance{symbol, [offset=0], [available=false]} Get the balance of a specific asset for current session.

Get the balance of a specific asset for current session.

Name	Type	Description
data	Object
data.symbol	string	The asset symbol.
data.offset	string	[Optional, default = 0] The account offset
data.available	string	[Optional, default = false] Only return available balance (minus the required fees)

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'getBalance'
    ]
      , onSuccess
      , onError
      , onProgress
    );

getFee{symbol, [source], [target], [amount]} Get the fee object of a specific asset for current session.

getKeys{symbol, [offset=0]} Get the keys associated to a specific asset for current session. Important: handle your private keys confidentially.

Get the keys associated to a specific asset for current session. Important: handle your private keys confidentially.

Name	Type	Description
data	Object
data.symbol	string	The asset symbol.
data.offset	number	[Optional, default = 0] The deterministic offset to use.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'getKeys'
    ]
      , onSuccess
      , onError
      , onProgress
    );

getLoginKeyPair{[username], [password], [offset=0]} Get the keys associated with a login username/password. Important: handle your private keys confidentially.

Get the keys associated with a login username/password. Important: handle your private keys confidentially.

Name	Type	Description
data	Object
data.username	string	[Optional] The login username.
data.password	string	[Optional] The login password.
data.offset	number	[Optional, default = 0] The eterministic offset to use.

    hybrix.sequential([
    {host: 'http://localhost:1111/'}, 'addHost',
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0', offset: 1}, 'getLoginKeyPair'
    ]
      , onSuccess
      , onError
      , onProgress
    );

getPrivateKey{symbol, [offset=0]} Get the private key associated to a specific asset for current session.

Get the private key associated to a specific asset for current session.

Name	Type	Description
data	Object
data.symbol	string	The asset symbol.
data.offset	number	[Optional, default = 0] The eterministic offset to use.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'getPrivateKey'
    ]
      , onSuccess
      , onError
      , onProgress
    );

getPublicKey{symbol, [offset=0]} Get the public key associated to a specific asset for current session.

Get the public key associated to a specific asset for current session.

Name	Type	Description
data	Object
data.symbol	string	The asset symbol.
data.offset	number	[Optional, default = 0] The deterministic offset to use.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'getPublicKey'
    ]
      , onSuccess
      , onError
      , onProgress
    );

getValuation{fromSymbol, toSymbol, [amount=balance], [cacheTime], [channel], [host]} Get the balance of a specific asset for current session.

Get the balance of a specific asset for current session.

Name	Type	Description
data	Object
data.fromSymbol	string	The asset symbol.
data.toSymbol	string	The asset symbol.
data.amount	string	[Optional, default = balance] Get valuation for amount
data.cacheTime	string	[Optional] Cachetime in ms
data.channel	string	[Optional] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.host	string	[Optional] Select a specific host, if omitted one will be chosen at random.

    hybrix.getValuation({fromSymbol: 'btc', toSymbol:'eth', amount:12}
      , onSuccess
      , onError
      , onProgress
    );

getValuations{fromSymbols, toSymbol, [cacheTime], [channel], [host]} Get the valuations rate of an array of assets.

Get the valuations rate of an array of assets.

Name	Type	Description
data	Object
data.fromSymbols	string	Array containing asset symbols.
data.toSymbol	string	The target asset symbol.
data.cacheTime	string	[Optional] Cachetime in ms.
data.channel	string	[Optional] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.host	string	[Optional] Select a specific host, if omitted one will be chosen at random.

    hybrix.getValuations({fromSymbols: ['btc:12','eth:1'], toSymbol:'eth'}
      , onSuccess
      , onError
      , onProgress
    );

initAsset{assetDetails, clientModuleCodeBlob, [offset=0], [check=true], [seed], [keys], [privateKey], [host], [channel]} Initialize an asset (crypto currency or token)

refreshAsset{[symbol], [cache=5000], [offset=0]} Update the balance of a given asset (or all assets if no symbol is defined)

Update the balance of a given asset (or all assets if no symbol is defined)

Name	Type	Description
data	Object
data.symbol	string	[Optional] The symbol of the asset to be refreshed, leave undefined to refresh all assets.
data.cache	string	[Optional, default = 5000] Asset will only be refreshed if data is older than this many milliseconds.
includeBaseAssets	string	Include the base assets. (The main chain for tokens)
data.offset	string	[Optional, default = 0] The deterministic offset

 hybrix.sequential([
 {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
 {host: 'http://localhost:1111/'}, 'addHost',
 {symbol: 'dummy'}, 'refreshAsset',
 ]
   , onSuccess
   , onError
   , onProgress
 );

removeAsset{symbol, [host], [channel], [offset=0]} Remove an asset (crypto currency or token) from the session.

Remove an asset (crypto currency or token) from the session.

Name	Type	Description
data	Object
data.symbol	string	The symbol of the asset
data.host	string	[Optional] The host used for the calls.
data.channel	string	[Optional] The channel used for the calls. 'y' for encryped, 'z' for encryped and compresses;
data.offset	number	[Optional, default = 0] The eterministic offset to use.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'addAsset',
    {symbol: 'dummy'}, 'removeAsset'
    ]
      , onSuccess
      , onError
      , onProgress
    );

setPrivateKey{symbol, privateKey} Set the private key associated to a specific asset for current session.

Set the private key associated to a specific asset for current session.

Name	Type	Description
data	Object
data.symbol	string	The asset symbol.
data.privateKey	string	The private key.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy', privateKey: '_dummyprivatekey_'}, 'setPrivateKey'
    ]
      , onSuccess
      , onError
      , onProgress
    );

ClientModule

client{[symbol], [id], func, data} Execute a function in a client module.

Execute a function in a client module.

Name	Type	Description
data	Object
data.symbol	string	[Optional] The asset symbol . Either this or the id needs to be defined.
data.id	string	[Optional] id of the client module. (For assets this is the first part of the mode)
data.func	string	The client module function to be called
data.data	string	The data to be passed to the client module function

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy', func:'address', data:{}}, 'client'
    ]
      , onSuccess
      , onError
      , onProgress
    );

export{[id]} Export a client module code blob.

Export a client module code blob.

Name	Type	Description
data	Object	if empty, exports all blobs
data.id	string	[Optional] id of the client code blob.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'addAsset',
    {id: 'dummycoin'},'export'
    ]
      , onSuccess
      , onError
      , onProgress
    );

import{id, blob, [check=true], [channel], [host]} Import a client module code blob.

modules{} List locally available client modules.

List locally available client modules.

Name	Type	Description
data	Object	ignored

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy'}, 'addAsset',
    'modules'
    ]
      , onSuccess
      , onError
      , onProgress
    );

Deprecated

init{} No longer required, is handled automatically before the first call

Encryption

code{data, [target='base256'], [source='base256']} Change encoding of a string from one format to the other.

Change encoding of a string from one format to the other.

Name	Type	Description
data	Object
data.data	Object	A string to encode.
data.target	String	[Optional, default = 'base256'] Target encoding.
data.source	String	[Optional, default = 'base256'] Source encoding.

    hybrix.sequential([
      {data:'hello world',source:'ascii',target:'hex'}, 'code'
    ]
      , onSuccess
      , onError
      , onProgress
    );

decrypt{data, [salt], [publicKey], [secretKey]} Decrypt and parse data with user keys.

Decrypt and parse data with user keys.

Name	Type	Description
data	Object
data.data	String	An encrypted and stringified string, array or object.
data.salt	Object	[Optional] Use an alternative encryption salt.
data.publicKey	Object	[Optional] Use an alternative public key.
data.secretKey	Object	[Optional] Use an alternative secret key.

    hybrix.sequential([
      {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
      {data:'Hello World!'}, 'encrypt',
      data=>{return {data:data}}, 'decrypt'
    ]
      , onSuccess
      , onError
      , onProgress
    );

encrypt{data, [salt], [publicKey], [secretKey]} Stringify and encrypt data with user keys.

Stringify and encrypt data with user keys.

Name	Type	Description
data	Object
data.data	Object	A string, array or object.
data.salt	Object	[Optional] Use an alternative encryption salt.
data.publicKey	Object	[Optional] Use an alternative public key.
data.secretKey	Object	[Optional] Use an alternative secret key.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {data:'Hello World!'}, 'encrypt'
    ]
      , onSuccess
      , onError
      , onProgress
    );

hash{data, [salt=''], [method=sha256]} Stringify and create a hash.

Stringify and create a hash.

Name	Type	Description
data	Object
data.data	Object	A string, array or object.
data.salt	String	[Optional, default = ''] A string to salt the hash with.
data.method	String	[Optional, default = sha256] Method to use for hashing. Available: md5, djb2, sha244, sha256

    hybrix.sequential([
      {data:'hello world'}, 'hash'
    ]
      , onSuccess
      , onError
      , onProgress
    );

keys{[secret]} Create signing keys

Create signing keys

Name	Type	Description
data	Object
data.secret	String	[Optional] The secret key to recreate a public key from.

    hybrix.sequential([
      'keys'                                          // generate random public and secret key pair
      {seed:true}, 'keys'                             // generate keys derived from current user seed
      someString => {seed:someString}, 'keys'         // generate keys derived from seed string
      mySecretKey => {secretKey:mySecretKey}, 'keys'  // return keypair for mySecretKey
    ]
      , onSuccess
      , onError
      , onProgress
    );

sign{message, [public], [secret], [signature]} Sign a message with a secret key or verify the signature for a public key.

Sign a message with a secret key or verify the signature for a public key.

Name	Type	Description
data	Object
data.message	String	The message to sign or open.
data.public	String	[Optional] The public key to verify.
data.secret	String	[Optional] The secret key to sign with.
data.signature	Boolean \| String	[Optional] Indication to create a detached signature or a detached signature to verify.

    var myKeys;
    hybrix.sequential([
    'keys',  // Create key pair
    keys => { myKeys = keys; }, // Store key pair
    myKeys => {return {message:'Hello World', secretKey:myKeys.secret}}, 'sign',                                   // Sign message with secret key, returns signature
    input => {return {message:'Hello World', publicKey:input.myKeys.public, signature:input.mySignature}}, 'sign'  // Verify message with public key and signature
    ]
      , onSuccess
      , onError
      , onProgress
    );

Flow

call{func, [data]} Execute a custom function with callbacks. Usefull for sequential and parallel.

Execute a custom function with callbacks. Usefull for sequential and parallel.

Name	Type	Description
data	Object
data.func	Function	A function expecting data, dataCallback, errorCallback and optional progressCallback parameters.
data.data	Object	[Optional] The data to be passed to the function. If ommitted and call is used in a sequential command it will be passed from previous step.

      hybrix.sequential([
        {func: (data,onSuccess,onError,onProgress)=>{                  // Declare a custom function
          onProgress(0.5);                                             // Set the progress to 50%
          setTimeout(onSuccess,2000,data+1);                           // Wait to seconds, then output result + 1
        }, data:1} , 'call'                                            // Provide the initial data
      ],
       onSuccess,                                                      // Define action to execute on successfull completion
       onError,                                                        // Define action to execute when an error is encountered
       onProgress                                                      // Define action to execute whenever there is a progress update
   );

id{} Identity function, outputs the data that is passed

Identity function, outputs the data that is passed

Name	Type	Description
data	Array	data passed to dataCallback

    hybrix.sequential([
    {hello:'world'}, 'id'
    ]
      , onSuccess
      , onError
      , onProgress
    );

parallel{$label, $label,data, $label,step, [_options], [_options,passErrors=false], [_options,failIfAllFail=true], [_options,failIfAnyFails=false]} Parallely executes several threads and collects results in a single object.

Parallely executes several threads and collects results in a single object.

Name	Type	Description
data	Object	Parallel steps to be processed.
data.$label	Object	A label given to the thread.
data.$label.data	Object	The initial data passed to this thread.
data.$label.step	Object	The step to execute with the data. Use 'sequential' to create multi step thread process.
data._options	Object	[Optional] An options object
data._options.passErrors	Object	[Optional, default = false] Whether to pass error results to the collected results object.
data._options.failIfAllFail	Object	[Optional, default = true] Whether fali stream if all steps fail
data._options.failIfAnyFails	Object	[Optional, default = false] Whether to fail entire stream if any step fail

    hybrix.sequential([
    {host: 'http://localhost:1111/'}, 'addHost',
    {fee: {data:{query:'/asset/dummy/fee'}, step: 'rout'}, factor: {data:{query:'/asset/dummy/factor'}, step: 'rout'}} , 'parallel'
    ]
      , onSuccess
      , onError
      , onProgress
    );

sequential{} Sequentually executes functions and passes results to next step.

Sequentually executes functions and passes results to next step.

Name	Type	Description
data	Array	Sequential steps to be processed. An object indicates data that is supplied to the next step. A function is a transformation of the data of the previous step and given to the next step. A string is a method that used the data from the last step and supplies to the next step.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {data:'Hello World!'}, 'encrypt',
    data=>{return {data:data}}, 'decrypt'
    ]
      , onSuccess
      , onError
      , onProgress
    );

Host

addHost{host, [regular=true], [encryptByDefault=false]} Add a hybrixd node as host.

Add a hybrixd node as host.

Name	Type	Description
data	Object
data.host	string	The hostname for the hybrixd node
data.regular	string	[Optional, default = true] Indicate whether this is a regular of specialized host. specialized hosts are skipped as default host
data.encryptByDefault	string	[Optional, default = false] Indicate whether to use y chan by default

    hybrix.sequential([
    {host: 'http://localhost:1111/'}, 'addHost'
    ]
      , onSuccess
      , onError
      , onProgress
    );

rout{query, [fallback], [channel], [meta=false], [retries=3], [cache=0], [host], [regular=true], [encryptByDefault=false], [data]} Make an api call to hybrixd node

Make an api call to hybrixd node

Name	Type	Description
data	Object
data.query	string	The query path. For reference: REST API help.
data.fallback	string	[Optional] Provide a fallback value in case of errors.
data.channel	string	[Optional] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.meta	Boolean	[Optional, default = false] Indicate whether to include meta data (process information).
data.retries	Boolean	[Optional, default = 3] Nr of retries for a call
data.cache	string	[Optional, default = 0] Add a cache time
data.host	string	[Optional] Select a specific host, if omitted one will be chosen at random.
data.regular	string	[Optional, default = true] If defining a new host, indicate whether it's a regular host.
data.encryptByDefault	string	[Optional, default = false] If defining a new host, indicate whether to use y chan by default
data.data	string	[Optional] POST data

    hybrix.sequential([
    {host: 'http://localhost:1111/'}, 'addHost',
    {query: '/asset/dummy/details'}, 'rout'
    ]
      , onSuccess
      , onError
      , onProgress
    );

Session

createAccount{[entropy], [offset], [pool]} Create a new deterministic account with the entropy provided.

login{host} Create an encrypted session with a host.

Create an encrypted session with a host.

Name	Type	Description
data	Object
data.host	string	The hostname for the hybrixd node.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {host: 'http://localhost:1111/'}, 'login'
    ]
      , onSuccess
      , onError
      , onProgress
    );

logout{} Log out of current session.

Log out of current session.

Name	Type	Description
data	Object	Not used

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    'logout'
    ]
      , onSuccess
      , onError
      , onProgress
    );

session{username, password, publicKey, secretKey, symbol, privateKey, [offset]} Create a local deterministic session and - if required - log out of current session.

Create a local deterministic session and - if required - log out of current session.

Name	Type	Description
data	Object
data.username	string	The username for the deterministic session
data.password	string	The password for the deterministic session
data.publicKey	string	The public key to use for the deterministic session (can not be used in combination with username/password!)
data.secretKey	string	The secret key to use for the deterministic session (can not be used in combination with username/password!)
data.symbol	string	The symbol to use for universal login
data.privateKey	string	The privateKey key to use for universal login(can not be used in combination with username/password!)
data.offset	string	[Optional] The offset to create alternative accounts

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session'
    ]
      , onSuccess
      , onError
      , onProgress
    );

Storage

burn{key, [sessionKey=false], [host], [channel=''], [local=true], [remote=true]} Delete a value in storage

Delete a value in storage

Name	Type	Description
data	Object
data.key	String	The key identifier for the data.
data.sessionKey	Boolean	[Optional, default = false] A toggle to use a sessionKey storage method.
data.host	String	[Optional] The host to store the data on.
data.channel	String	[Optional, default = ''] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.local	Boolean	[Optional, default = true] Whether to use local storage if available
data.remote	Boolean	[Optional, default = true] Whether to use remote storage

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {key:'Hello', value:'World!'}, 'save',
    {key:'Hello'}, 'burn'
    ]
      , onSuccess
      , onError
      , onProgress
    );

list{pattern, [sessionKey=false], [host], [channel=''], [local=true], [remote=true]} Check which keys matching a given pattern exist in hybrixd node storage

Check which keys matching a given pattern exist in hybrixd node storage

Name	Type	Description
data	Object
data.pattern	String	The pattern identifier for the data.
data.sessionKey	Boolean	[Optional, default = false] A toggle to use a sessionKey storage method.
data.host	String	[Optional] The host to store the data on.
data.channel	String	[Optional, default = ''] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.local	Boolean	[Optional, default = true] Whether to use local storage if available
data.remote	Boolean	[Optional, default = true] Whether to use remote storage

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {pattern:'HelloWorld', value:'World!'}, 'save',
    {pattern:'HelloUniverse', value:'Universe!'}, 'save',
    {pattern:'Hello'}, 'list'
    ]
      , onSuccess
      , onError
      , onProgress
    );

load{key, [encrypted=true], [sessionKey=false], [fallback], [host], [channel=''], [local=true], [remote=true], [mergeStrategy=(local,remote)], [sync=true]} Retrieve value associated with key from the hybrixd node storage

Retrieve value associated with key from the hybrixd node storage

Name	Type	Description
data	Object
data.key	String	The key identifier for the data.
data.encrypted	Boolean	[Optional, default = true] whether to encrypt the data with the user key, true by default.
data.sessionKey	Boolean	[Optional, default = false] A toggle to use a sessionKey storage method.
data.fallback	String	[Optional] Provide a fallback value, if call fails this value is used
data.host	String	[Optional] The host to store the data on.
data.channel	String	[Optional, default = ''] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.local	Boolean	[Optional, default = true] Whether to use local storage if available
data.remote	Boolean	[Optional, default = true] Whether to use remote storage
data.mergeStrategy	Boolean	[Optional, default = (local,remote)] What to do if results from local and remote storage differs
data.sync	Boolean	[Optional, default = true] If only available on either remote or storage, save it to the other as well

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {key:'Hello', value:'World!'}, 'save',
    {key:'Hello'}, 'load'
    ]
      , onSuccess
      , onError
      , onProgress
    );

meta{key, [host], [channel], [meta=false]} Retrieve the meta data for a storage key

Retrieve the meta data for a storage key

Name	Type	Description
data	Object
data.key	String	The key identifier for the data.
data.host	String	[Optional] The host to store the data on.
data.channel	String	[Optional] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.meta	Boolean	[Optional, default = false] Indicate whether to include meta data (process information).

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {key:'Hello', value:'World!'}, 'save',
    {key:'Hello'}, 'meta'
    ]
      , onSuccess
      , onError
      , onProgress
    );

save{key, value, [sessionKey=false], [encrypted=true], [work=true], [queue=false], [submit=true], [host], [channel=''], [local=true], [remote=true]} Stringify and encrypt data with user keys.

Stringify and encrypt data with user keys.

Name	Type	Description
data	Object
data.key	String	The key identifier for the data.
data.value	Object	A string, array or object.
data.sessionKey	Boolean	[Optional, default = false] A toggle to use a sessionKey storage method.
data.encrypted	Boolean	[Optional, default = true] whether to encrypt the data with the user key.
data.work	String	[Optional, default = true] whether to perform proof of work.
data.queue	String	[Optional, default = false] whether to queue proof of work. Execute later with queue method
data.submit	String	[Optional, default = true] whether to submit proof of work.
data.host	String	[Optional] The host to store the data on.
data.channel	String	[Optional, default = ''] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.local	Boolean	[Optional, default = true] Whether to use local storage if available
data.remote	Boolean	[Optional, default = true] Whether to use remote storage

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {key:'Hello', value:'World!'}, 'save',
    {key:'Hello'}, 'load'
    ]
      , onSuccess
      , onError
      , onProgress
    );

seek{key, [sessionKey=false], [host], [channel=''], [local=true], [remote=true]} Check if a value is associated with key in the hybrixd node storage

Check if a value is associated with key in the hybrixd node storage

Name	Type	Description
data	Object
data.key	String	The key identifier for the data.
data.sessionKey	Boolean	[Optional, default = false] A toggle to use a sessionKey storage method.
data.host	String	[Optional] The host to store the data on.
data.channel	String	[Optional, default = ''] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.local	Boolean	[Optional, default = true] Whether to use local storage if available
data.remote	Boolean	[Optional, default = true] Whether to use remote storage

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {key:'Hello', value:'World!'}, 'save',
    {key:'Hello'}, 'seek'
    ]
      , onSuccess
      , onError
      , onProgress
    );

work{challenge, difficulty, [submit], [key], [host], [channel], [meta=false]} Perform Proof of Work required to extend saved data retention.

Transaction

addPending{transactiontransaction,ref, transaction,meta, transaction,type, [transaction,timestamp=now]], [transaction,status=0], [sync=true]} Add pending transaction(s)

Add pending transaction(s)

Name	Type	Description
data.transaction	Object \| Array	Transaction object or array of transactions objects
data.transaction.ref	String	Transaction object requires a unique reference id
data.transaction.meta	Object	Transaction object requires a unique reference id
data.transaction.type	Object	Transaction object requires a unique reference id
data.transaction.timestamp	Number	[Optional, default = now]]
data.transaction.status	Number	[Optional, default = 0]
data.sync	String	[Optional, default = true] Whether to synchronize the data with storage

    hybrix.sequential([
      {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
      {ref:'test', type:'regular', meta:{symbol:'dummy',id:'TX01'}}, 'addPending'
    ]
      , onSuccess
      , onError
      , onProgress
    );

assert{} Test a condition and fail with a message if condition is not met

Test a condition and fail with a message if condition is not met

Name	Type	Description
data	Object
condition	Boolean	The condition to test
message	String	The message to display if condition is not met

    hybrix.sequential([
      {condition: true===false, password: 'Failed on purpose. True is not equal to false.'}, 'assert'
    ]
      , onSuccess
      , onError
      , onProgress
    );

getPending{, data, [refresh=true], [remove=true], [sync=true]} Merge the stored pending transactions with the existing ones

Merge the stored pending transactions with the existing ones

Name	Type	Description
storedPendingTransactions	{object	[description] const mergeStoredPending = (pendingTransactions, hasSession, data, dataCallback, errorCallback) => function (storedPendingTransactions) { pendingTransactions = mergeStrategy(pendingTransactions, storedPendingTransactions); return refreshPending.bind(this)(pendingTransactions, hasSession, data, dataCallback, errorCallback); }; / secondary merge strategy to resolve conflicts in remote and local storage
local	{[type]	[description]
remote	{[type]	[description]
data	Object
data.data	String	An encrypted and stringified string, array or object.
data.refresh	Object	[Optional, default = true] Whether to update the status first
data.remove	Object	[Optional, default = true] Whether to remove confirmed or finalized transaction
data.sync	Object	[Optional, default = true] Whether to synchronize the data with storage (if refreshed)

    hybrix.sequential([
      {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
      {ref:'test', type:'regular', meta:{symbol:'dummy',id:'TX01'}}, 'addPending',
      'getPending'
    ]
      , onSuccess
      , onError
      , onProgress
    );

rawTransaction{symbol, target, amount, [validate=true], [message], [unspent], [source=address], [offset=0], [comparisonSymbol=hy], [fee], [time], [host], [channel]} Creates a raw transaction that is signed but not yet pushed to the network. Required assets and inputs are collected accordingly.

Creates a raw transaction that is signed but not yet pushed to the network. Required assets and inputs are collected accordingly.

Name	Type	Description
data	Object
data.symbol	String	The symbol of the asset
data.target	String	The target address
data.amount	Number	The amount that should be transferred
data.validate	Boolean	[Optional, default = true] Validate target address and available funds.
data.message	String	[Optional] Option to add data (message, attachment, op return) to a transaction.
data.unspent	Object	[Optional] Manually set the unspent data
data.source	String	[Optional, default = address] Provide optional (partial) source address.
data.offset	number	[Optional, default = 0] The deterministic offset
data.comparisonSymbol	String	[Optional, default = hy] Provide symbol to compare fees for multi transactions
data.fee	Number	[Optional] The fee.
data.time	Number	[Optional] Provide an explicit time timestamp.
data.host	String	[Optional] The host that should be used.
data.channel	String	[Optional] Indicate the channel 'y' for encryption, 'z' for both encryption and compression

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy', target: '_dummyaddress_', amount:1}, 'rawTransaction',
    ]
      , onSuccess
      , onError
      , onProgress
    );

signTransaction{symbol, target, amount, [message], [fee], [time], [offset=0], unspent} Create a signed transaction using all inputs.

Create a signed transaction using all inputs.

Name	Type	Description
data	object
data.symbol	string	The symbol of the asset.
data.target	string	The target address.
data.amount	number	The amount.
data.message	number	[Optional] Option to add data (message, attachment, op return) to a transaction.
data.fee	number	[Optional] The fee.
data.time	number	[Optional] Provide an explicit timestamp.
data.offset	number	[Optional, default = 0] The source offset
data.unspent	object	Pretransaction data.

 hybrix.sequential([
 {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
 {host: 'http://localhost:1111/'}, 'addHost',
 {symbol: 'dummy'}, 'addAsset',
 {symbol: 'dummy', target: '_dummyaddress_', amount:1, unspent: [{"amount":"1","txid":"TXIDTXIDTXIDTXIDTXIDTXIDTXID","txn":1}]}, 'rawTransaction',
 ]
 , onSuccess
 , onError
 , onProgress
 );

transaction{symbol, target, amount, [validate=true], [message], [unspent], [source=address], [comparisonSymbol=hy], [offset=0], [fee], [time], [host], [channel], [addToPending=true]} Create, sign and execute a transaction e.g. push it into the network.

Create, sign and execute a transaction e.g. push it into the network.

Name	Type	Description
data	Object
data.symbol	String	The symbol of the asset
data.target	String	The target address
data.amount	Number	The amount that should be transferred
data.validate	Boolean	[Optional, default = true] Validate target address and available funds.
data.message	String	[Optional] Option to add data (message, attachment, op return) to a transaction.
data.unspent	Object	[Optional] Manually set the unspent data
data.source	String	[Optional, default = address] Provide optional (partial) source address.
data.comparisonSymbol	String	[Optional, default = hy] Provide symbol to compare fees for multi transactions
data.offset	number	[Optional, default = 0] The source offset
data.fee	Number	[Optional] The fee.
data.time	Number	[Optional] Provide an explicit time timestamp.
data.host	String	[Optional] The host that should be used.
data.channel	String	[Optional] Indicate the channel 'y' for encryption, 'z' for both encryption and compression
data.addToPending	Boolean	[Optional, default = true] Indicate whether to add the transaction to pending transaction list.

    hybrix.sequential([
    {username: 'DUMMYDUMMYDUMMY0', password: 'DUMMYDUMMYDUMMY0'}, 'session',
    {host: 'http://localhost:1111/'}, 'addHost',
    {symbol: 'dummy', target: '_dummyaddress_', amount:1}, 'transaction',
    ]
      , onSuccess
      , onError
      , onProgress
    );
   
const sha256 = require('js-sha256')
const TX_MAX_GET_LENGTH = 0;  // all transactions currently default to using POST method

Misc

atom{amount, [factor], [symbol]} Convert decimal numbers to atomic numbers

Convert decimal numbers to atomic numbers

Name	Type	Description
data	Object
data.amount	string	amount to be formatted
data.factor	string	[Optional] number of decimals
data.symbol	string	[Optional] symbol of asset, can be used to retrieve the factor

    hybrix.sequential([
      {amount:10, factor: 8}, 'attom'
    ]
      , onSuccess
      , onError
      , onProgress
    );

Name	Type	Description
data	Object
data.assetDetails	Object	Asset details as retrieved by calling `/a/$SYMBOL/details`
data.clientModuleCodeBlob	string	A string containing the client module code blob.
data.offset	integer	[Optional, default = 0] The deterministic offset
data.check	Boolean	[Optional, default = true] Whether to check if the provided clientModuleCodeBlob matches the remote version
data.seed	string	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Pass a custom see
data.keys	string	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Pass a keypair
data.privateKey	string	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Pass a privateKey
data.host	string	[Optional] The host used for the calls.
data.channel	string	[Optional] The channel used for the calls. 'y' for encryped, 'z' for encryped and compresses;

Name	Type	Description
data	Object
data.entropy	string	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Entropy can be provided. Must be a sufficient random string of at least 482 bytes.
data.offset	Function	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Use an offset to create multiple accounts from same entropy.
data.pool	Function	[Optional] CAREFUL! Using this feature incorrectly can reduce your security and privacy. Only use when you know what you're doing. Pool function can be overridden by a custom 1600 byte pool generator. deterministic

Name	Type	Description
data	Object
data.challenge	Object	The hint that needs to be worked.
data.difficulty	Object	The difficulty of the work
data.submit	string	[Optional] Whether to submit the proof of work
data.key	Object	[Optional] Required for submit
data.host	String	[Optional] The host to store the data on.
data.channel	String	[Optional] Indicate the channel 'y' for encryption, 'z' for both encryption and compression.
data.meta	Boolean	[Optional, default = false] Indicate whether to include meta data (process information).