How to use the ripple-lib.Remote function in ripple-lib

var Campaign = function(db,config) {
    var self = this;
    // list all users joined with the memoization table campaigns
    var remote = new RL.Remote(config.ripplelib);
    var checktimer;
    var check = function() {
        var now = new Date();
        var timetill = new Date(now.getFullYear(), now.getMonth(), now.getDate(), config.schedule.hour, config.schedule.minute, 0, 0) - now;
        if (timetill < 0) 
            timetill += 86400000; // one day
        self.probe({action:'check',timetill:timetill})
        checktimer = setTimeout(work,timetill);
    };
    // additional time is only set for testing purposes
    var work = function(additional_time) {
        console.log("work")
        self.probe({action:'work'})
        var q = new QL;
        q.series([
        // create table of users of unfunded or unchecked

}
};

if (process.argv.length < 4 || process.argv.length > 7) {
  console.log("Usage: %s ws_ip ws_port [ [ []]]", program);
}
else {
  var ws_ip   = process.argv[2];
  var ws_port = process.argv[3];
  var ip      = process.argv.length > 4 ? process.argv[4] : "127.0.0.1";
  var port    = process.argv.length > 5 ? process.argv[5] : "8080";

// console.log("START");
  var self  = this;
  
  var remote  = (new Remote({
                    websocket_ip: ws_ip,
                    websocket_port: ws_port,
                    trace: false
                  }))
                  .on('state', function (m) {
                      console.log("STATE: %s", m);

                      self.state   = m;
                    })
//                  .once('ledger_closed', callback)
                  .connect()
                  ;

  self.base = {
      hostname: ip,
      port:     port,

/* Loading ripple-lib with Node.js */
var Remote = require( 'ripple-lib' ).Remote;
var Amount = require( 'ripple-lib' ).Amount;

/* Loading ripple-lib in a webpage */
// var Remote = ripple.Remote;
// var Amount = ripple.Amount;

/* Connect to rippled through ripple-lib */
var remote = new Remote( {
  // trace: true,
  servers: [ {
    host: 's_west.ripple.com',
    port: 443
  } ]
} );
remote.connect( );

/* views maps the available txProcessor functions to their view names */
var views = {
  "account_tx": extractAccountTx,
  "offersExercised": extractOffersExercised

  // TODO add more views
};

/* Loading ripple-lib with Node.js */
var Remote = require('ripple-lib').Remote;
var Amount = require('ripple-lib').Amount;

/* Loading ripple-lib in a webpage */
// var Remote = ripple.Remote;
// var Amount = ripple.Amount;

var remote = new Remote({
    // see the API Reference for available options
    trusted: true,
    local_signing: true,
    local_fee: true,
    fee_cushion: 1.5,
    servers: [{
        host: 's1.ripple.com',
        port: 443,
        secure: true
    }]
});

getOrderBook(["XRP"], ["USD", "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"]);

function getOrderBook(curr1, curr2, callback) {
    remote.connect(function() {

return new Promise(function (resolve, reject) {
          if (!options.secret) {
            reject(new Error("options.secret must be provided to sign offer"));
          }

          var remote = new ripple.Remote({
            servers: ["wss://s1.ripple.com:443"]
          });

          remote.connect(function () {
            remote.setSecret(_this.account, options.secret);

            var transaction = remote.createTransaction("OfferCreate", {
              account: _this.account,
              taker_pays: _this.sell.amount + "/" + _this.sell.currency,
              taker_gets: _this.buy.amount + "/" + _this.buy.currency
            });

            transaction.submit(function (err, res) {
              if (err) {
                return reject(err);
              }

function NotificationMonitor (opts) {

  console.log(JSON.stringify(opts));

  this.monitoring = false;

  if (opts.remote) {

    this.remote = opts.remote;

  } else if (opts.servers) {

    this.remote = new ripple.Remote(opts);
    
  } else {
    throw(new Error('NotificationMonitor requires a connected remote or a list of servers'));
  }


  if (opts.startLedger) {
    this.lastCheckedLedger = opts.startLedger - 1;
  }

  if (opts.interval) {
    this.intervalLength = opts.interval;
  } else {
    this.intervalLength = 20000;
  }

function RippleInterface (opts) {

  if (opts[0] && opts[0].host) {
    opts = {servers: opts};
  }

  if (opts.local_signing === null || opts.local_signing === undefined) {
    opts.local_signing = true;
  }

  this.remote = new ripple.Remote(opts);

  this.remote.connect();
}

store.initSync();
var importer = { };

if (reset) {
  importer.validated = null;
  importer.last      = null;
  store.setItem('first', null);
  store.setItem('validated', null);
  store.setItem('last', null);
} else {
  importer.validated = store.getItem('validated');
  importer.last      = store.getItem('last');
}

importer.first  = {index : config.startIndex || 32570};
importer.remote = new ripple.Remote(options);

winston.info("first ledger: ", importer.first ? importer.first.index : "");
winston.info("last validated ledger: ", importer.validated ? importer.validated.index : "");
winston.info("latest ledger: ", importer.last ? importer.last.index : "");



importer.start = function () {
  importer.remote.connect();
  
  importer.remote.on('ledger_closed', function(resp){
    winston.info("ledger closed:", resp.ledger_index); 
    importer.getLedger(resp.ledger_index, function(err, ledger) {
      if (ledger) indexer.pingCouchDB();
    });
  });

var LedgerStream = function () {
  var self   = this;
  var remote = new ripple.Remote(options);
  
  remote.on('connect', function() {
    winston.info("connected");
  });

  remote.on('disconnect', function() {
    winston.info("disconnected");
  }); 
      
  /**
   * backFill
   * begin a new backfilling thread
   */
  self.backFill = function (stopIndex, startIndex) {
    var bf = new BackFiller(stopIndex, startIndex, function(){
      delete bf;

var Stellar = require('stellar-lib')
var Ripple = require('ripple-lib')
var constants = require('./constants')

var stellar = exports[constants.networks.STELLAR] = new Stellar.Remote({
  servers: [{
    host: 'live.stellar.org',
    port: 9001,
    secure: true
  }]
})

var ripple = exports[constants.networks.RIPPLE] = new Ripple.Remote({
  servers: [{
    host: 's1.ripple.com',
    port: 443,
    secure: true
  }]
})

ripple.connect()
stellar.connect()