How to use the bitcoinjs-lib.Script function in bitcoinjs-lib

//      if (err) return done(err)
//        console.log("unspent",unspent,transaction);
//    });

    var tx = new bitcoin.TransactionBuilder()

//    var redeemScript = bitcoin.scripts.multisigOutput(2, pubKeys) // 2 of 3
//    var scriptPubKey = bitcoin.scripts.scriptHashOutput(redeemScript.getHash())
//    var address = bitcoin.Address.fromOutputScript(scriptPubKey, bitcoin.networks.testnet).toString()

//    var data = new Buffer('cafedeadbeef', 'hex')
//    var dataScript = bitcoin.Script.fromChunks([bitcoin.opcodes.OP_RETURN, data]);
    
    var secret = crypto.randomBytes(4);
    var hash = crypto.createHash('sha256').update(secret).digest();
    var hashScript = bitcoin.Script.fromChunks([bitcoin.opcodes.OP_HASH256, hash, bitcoin.opcodes.OP_EQUALVERIFY]);

    tx.addInput(unspent.txHash, unspent.index)
    tx.addOutput(hashScript, 2000)
    tx.sign(0, key)

    var hex = tx.build().toHex();
    console.log("TX-HEX",hex);
    helloblock.transactions.propagate(hex, function(err) {
      if (err) return done(err)

      // check that the message was propagated
      helloblock.addresses.getTransactions(address, function(err, res, transactions) {
        if (err) return done(err)

        var transaction = transactions[0]
        var output = transaction.outputs[0]

else
                    throw new errors.CCTransactionConstructionError({explanation: 'have hashes and enough room we offested inputs for nothing'})
              }

               // add array of colored ouput indexes
                encoder.payments.forEach(function (payment) {
                  if (typeof payment.output !== 'undefined') coloredOutputIndexes.push(payment.output)
                })
                 
            }
            catch(e) {
              console.log(e)
              deferred.reject(e)
            }
            console.log("encoding done")
            var ret = bitcoinjs.Script.fromChunks(
                                    [
                                      bitcoinjs.opcodes.OP_RETURN,
                                      buffer.codeBuffer
                                    ]);

            tx.addOutput(ret, 0);
            var lastOutputValue = getChangeAmount(tx, metadata.fee, totalInputs)
            var coloredChange = _.keys(assetList).some(function (assetId) {
              return assetList[assetId].change > 0
            })
            var numOfChanges = (metadata.flags && metadata.flags.splitChange && coloredChange && lastOutputValue >= 2 * config.mindustvalue) ? 2 : 1

            if(lastOutputValue < numOfChanges * config.mindustvalue) {
              console.log('trying to add additionl inputs to cover transaction')
              satoshiCost = getInputAmountNeededForTx(tx, metadata.fee) + numOfChanges * config.mindustvalue
              if(!tryAddingInputsForFee(tx, utxos, totalInputs, metadata, satoshiCost)) {

function addHashesOutput(tx, address, sha2, sha1) {
      var chunks = []
      chunks.push(bitcoinjs.opcodes.OP_1)
      chunks.push(address ? new Buffer(address, 'hex') : new Buffer('03ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 'hex'))
      chunks.push(Buffer.concat([new Buffer('03', 'hex'), sha2], 33))
      if(sha1) {
        chunks.push(Buffer.concat([new Buffer('030000000000000000000000', 'hex'), sha1], 33))
        chunks.push(bitcoinjs.opcodes.OP_3)
      }
      else
        chunks.push(bitcoinjs.opcodes.OP_2)
      chunks.push(bitcoinjs.opcodes.OP_CHECKMULTISIG)

      console.log(chunks)   

      var script = bitcoinjs.Script.fromChunks(chunks)

      //try compute value to pass mindust
      //TODO: actually comput it with the fee from the api request, this assumes static fee per kb
      tx.outs.unshift({ script: script, value: getNoneMinDustByScript(script) })
    }

var hasEnoughEquity = utxos.some(function (utxo) {
            utxo.value = Math.round(utxo.value)
              if (!isInputInTx(tx, utxo.txid, utxo.index) && !(utxo.assets && utxo.assets.length)) {
                  console.log('current amount ' + utxo.value + " needed " + missing)
                  tx.addInput(utxo.txid, utxo.index)
                  inputsValue.amount += utxo.value
                  currentAmount = currentAmount.add(utxo.value)
                  if(metadata.flags && metadata.flags.injectPreviousOutput) {
                    tx.ins[tx.ins.length -1].script = bitcoinjs.Script.fromHex(utxo.scriptPubKey.hex)
                  }  

              }
              return currentAmount.comparedTo(missingbn) >= 0 

            })

var createSignedTransaction = function(options, callback) {
  var tipTransactionHash = options.tipTransactionHash;
  var tipDestinationAddress = options.tipDestinationAddress;
  var tipAmount = options.tipAmount || 10000;
  var data = new Buffer(headerHex + tipTransactionHash, "hex");
  var commonWallet = options.commonWallet;
  var commonBlockchain = options.commonBlockchain;
  var signTransaction = signFromTransactionHex(commonWallet.signRawTransaction);
  options.signTransaction = signTransaction;
  var address = commonWallet.address;
  var fee = options.fee || 1000;
  var payloadScript = Bitcoin.Script.fromChunks([Bitcoin.opcodes.OP_RETURN, data]);
  var tx = new Bitcoin.TransactionBuilder();
  commonBlockchain.Addresses.Unspents([address], function(err, addresses_unspents) {
    var unspentOutputs = addresses_unspents[0];
    var compare = function(a,b) {
      if (a.value < b.value)
        return -1;
      if (a.value > b.value)
        return 1;
      return 0;
    };
    unspentOutputs.sort(compare);
    var unspentValue = 0;
    for (var i = unspentOutputs.length - 1; i >= 0; i--) {
      var unspentOutput = unspentOutputs[i];
      if (unspentOutput.value === 0) {
        continue;

var createTransactionWithPayload = function(payload, primaryTxHex) {
  var primaryTx = primaryTxHex ? bitcoin.TransactionBuilder.fromTransaction(bitcoin.Transaction.fromHex(primaryTxHex)) : false;
  var lengthBuffer = new Buffer(1);
  lengthBuffer.writeUInt8(payload.length, 0);
  var payloadScript = bitcoin.Script.fromBuffer(Buffer.concat([OP_RETURN_BUFFER, lengthBuffer, payload]));
  var tx = primaryTx || new bitcoin.TransactionBuilder();
  tx.addOutput(payloadScript, 0);
  return tx;
};

'use strict';

var xhr = require('xhr')
var Address = require('./address')
var Transaction = require('./transaction')
var Script = require('bitcoinjs-lib').Script

function Blockchain(testnet){
  if(testnet) throw new Error("testnet not supported")
}
Blockchain.apiRoot = "https://blockchain.info/"
Blockchain.corsParam = "cors=true"

function listAddresses(addresses, onAddresses, onTransactions){
  if(!addresses || !addresses.length) {
    var error = new Error("Addresses can't be blank")
    return onAddresses(error)
  }

  makeRequest('multiaddr', ["active=" + addresses.join('|')], function (err, resp, body) {
    if(err) return onAddresses(err)

this.unspentOutputs = response.map(function(output) {
      return {
        hash: output.txid,
        index: output.vout,
        amount: output.satoshis,
        script: Bitcoin.Script.fromHex(output.scriptPubKey)
      }
    });

var createSignedTransactionWithData = function(options, callback) {
  var signTransaction = options.signTransaction || signFromTransactionHex(options.signTransactionHex) || signFromPrivateKeyWIF(options.privateKeyWIF);
  options.signTransaction = signTransaction;
  var data = options.data;
  if (data.length > 40) {
    callback("too large", false);
    return;
  };
  var address = options.address;
  var fee = options.fee || 1000;
  var privateKeyWIF = options.privateKeyWIF;
  var payloadScript = Bitcoin.Script.fromChunks([Bitcoin.opcodes.OP_RETURN, data]);
  var tx = new Bitcoin.TransactionBuilder();
  var unspentOutputs = options.unspentOutputs;
  var compare = function(a,b) {
    if (a.value < b.value)
      return -1;
    if (a.value > b.value)
      return 1;
    return 0;
  };
  unspentOutputs.sort(compare);
  var unspentValue = 0;
  for (var i = unspentOutputs.length - 1; i >= 0; i--) {
    var unspentOutput = unspentOutputs[i];
    if (unspentOutput.value === 0) {
      continue;
    }

'use strict';

var xhr = require('hive-xhr')
var Address = require('./address')
var Transaction = require('./transaction')
var Script = require('bitcoinjs-lib').Script

function Blockchain(testnet){
  if(testnet) throw new Error("testnet not supported")
}
Blockchain.apiRoot = "https://blockchain.info/"
Blockchain.corsParam = "cors=true"

function listAddresses(addresses, onAddresses, onTransactions){
  if(!addresses || !addresses.length) {
    var error = new Error("Addresses can't be blank")
    return onAddresses(error)
  }

  makeRequest('multiaddr', ["active=" + addresses.join('|')], function (err, resp, body) {
    if(err) return onAddresses(err)