diff --git a/src/address.js b/src/address.js
index 98eb888..9b9da05 100644
--- a/src/address.js
+++ b/src/address.js
@@ -20,10 +20,10 @@ function fromBase58Check (address) {
 function fromOutputScript (script, network) {
   network = network || networks.bitcoin
 
-  if (scripts.isPubKeyHashOutput(script)) return toBase58Check(Script.fromBuffer(script).chunks[2], network.pubKeyHash)
-  if (scripts.isScriptHashOutput(script)) return toBase58Check(Script.fromBuffer(script).chunks[1], network.scriptHash)
+  if (scripts.isPubKeyHashOutput(script)) return toBase58Check(script[2], network.pubKeyHash)
+  if (scripts.isScriptHashOutput(script)) return toBase58Check(script[1], network.scriptHash)
 
-  throw new Error(Script.fromBuffer(script).toASM() + ' has no matching Address')
+  throw new Error(Script.toASM(script) + ' has no matching Address')
 }
 
 function toBase58Check (hash, version) {
diff --git a/src/script.js b/src/script.js
index 211c74d..0e29f73 100644
--- a/src/script.js
+++ b/src/script.js
@@ -1,17 +1,30 @@
 var bufferutils = require('./bufferutils')
-var crypto = require('./crypto')
+var opcodes = require('./opcodes')
 var typeforce = require('typeforce')
 var types = require('./types')
-var opcodes = require('./opcodes')
 
-function Script (buffer, chunks) {
-  typeforce(types.tuple(types.Buffer, types.Array), arguments)
-
-  this.buffer = buffer
-  this.chunks = chunks
+function coerceChunks (chunks) {
+  return types.Array(chunks) ? chunks : decompile(chunks)
 }
 
-Script.fromASM = function (asm) {
+function toASM (chunks) {
+  chunks = coerceChunks(chunks)
+
+  return chunks.map(function (chunk) {
+    // data chunk
+    if (Buffer.isBuffer(chunk)) {
+      return chunk.toString('hex')
+
+    // opcode
+    } else {
+      return reverseOps[chunk]
+    }
+  }).join(' ')
+}
+
+function fromASM (asm) {
+  typeforce(types.String, asm)
+
   var strChunks = asm.split(' ')
   var chunks = strChunks.map(function (strChunk) {
     // opcode
@@ -24,44 +37,10 @@ Script.fromASM = function (asm) {
     }
   })
 
-  return Script.fromChunks(chunks)
+  return chunks
 }
 
-Script.fromBuffer = function (buffer) {
-  var chunks = []
-  var i = 0
-
-  while (i < buffer.length) {
-    var opcode = buffer.readUInt8(i)
-
-    // data chunk
-    if ((opcode > opcodes.OP_0) && (opcode <= opcodes.OP_PUSHDATA4)) {
-      var d = bufferutils.readPushDataInt(buffer, i)
-
-      // did reading a pushDataInt fail? return non-chunked script
-      if (d === null) return new Script(buffer, [])
-      i += d.size
-
-      // attempt to read too much data?
-      if (i + d.number > buffer.length) return new Script(buffer, [])
-
-      var data = buffer.slice(i, i + d.number)
-      i += d.number
-
-      chunks.push(data)
-
-    // opcode
-    } else {
-      chunks.push(opcode)
-
-      i += 1
-    }
-  }
-
-  return new Script(buffer, chunks)
-}
-
-Script.fromChunks = function (chunks) {
+function compile (chunks) {
   typeforce(types.Array, chunks)
 
   var bufferSize = chunks.reduce(function (accum, chunk) {
@@ -93,28 +72,43 @@ Script.fromChunks = function (chunks) {
   })
 
   if (offset !== buffer.length) throw new Error('Could not decode chunks')
-  return new Script(buffer, chunks)
+  return buffer
 }
 
-Script.fromHex = function (hex) {
-  return Script.fromBuffer(new Buffer(hex, 'hex'))
-}
+function decompile (buffer) {
+  typeforce(types.Buffer, buffer)
 
-Script.EMPTY = Script.fromChunks([])
+  var chunks = []
+  var i = 0
 
-Script.prototype.equals = function (script) {
-  return bufferutils.equal(this.buffer, script.buffer)
-}
+  while (i < buffer.length) {
+    var opcode = buffer.readUInt8(i)
 
-Script.prototype.getHash = function () {
-  return crypto.hash160(this.buffer)
-}
+    // data chunk
+    if ((opcode > opcodes.OP_0) && (opcode <= opcodes.OP_PUSHDATA4)) {
+      var d = bufferutils.readPushDataInt(buffer, i)
 
-// FIXME: doesn't work for data chunks, maybe time to use buffertools.compare...
-Script.prototype.without = function (needle) {
-  return Script.fromChunks(this.chunks.filter(function (op) {
-    return op !== needle
-  }))
+      // did reading a pushDataInt fail? empty script
+      if (d === null) return []
+      i += d.size
+
+      // attempt to read too much data? empty script
+      if (i + d.number > buffer.length) return []
+
+      var data = buffer.slice(i, i + d.number)
+      i += d.number
+
+      chunks.push(data)
+
+    // opcode
+    } else {
+      chunks.push(opcode)
+
+      i += 1
+    }
+  }
+
+  return chunks
 }
 
 var reverseOps = []
@@ -123,25 +117,9 @@ for (var op in opcodes) {
   reverseOps[code] = op
 }
 
-Script.prototype.toASM = function () {
-  return this.chunks.map(function (chunk) {
-    // data chunk
-    if (Buffer.isBuffer(chunk)) {
-      return chunk.toString('hex')
-
-    // opcode
-    } else {
-      return reverseOps[chunk]
-    }
-  }).join(' ')
+module.exports = {
+  compile: compile,
+  decompile: decompile,
+  toASM: toASM,
+  fromASM: fromASM
 }
-
-Script.prototype.toBuffer = function () {
-  return this.buffer
-}
-
-Script.prototype.toHex = function () {
-  return this.toBuffer().toString('hex')
-}
-
-module.exports = Script
diff --git a/src/scripts.js b/src/scripts.js
index 5437cdb..ec836fb 100644
--- a/src/scripts.js
+++ b/src/scripts.js
@@ -40,105 +40,102 @@ function isCanonicalSignature (buffer) {
   return true
 }
 
-function isPubKeyHashInput (script) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
-
-  return script.chunks.length === 2 &&
-    isCanonicalSignature(script.chunks[0]) &&
-    isCanonicalPubKey(script.chunks[1])
+function coerceBuffer (buffer) {
+  return types.Buffer(buffer) ? buffer : Script.compile(buffer)
 }
 
-function isPubKeyHashOutput (script) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
-
-  return script.chunks.length === 5 &&
-    script.chunks[0] === ops.OP_DUP &&
-    script.chunks[1] === ops.OP_HASH160 &&
-    Buffer.isBuffer(script.chunks[2]) &&
-    script.chunks[2].length === 20 &&
-    script.chunks[3] === ops.OP_EQUALVERIFY &&
-    script.chunks[4] === ops.OP_CHECKSIG
+function coerceChunks (chunks) {
+  return types.Array(chunks) ? chunks : Script.decompile(chunks)
 }
 
-function isPubKeyInput (script) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
+function isPubKeyHashInput (chunks) {
+  chunks = coerceChunks(chunks)
 
-  return script.chunks.length === 1 &&
-    isCanonicalSignature(script.chunks[0])
+  return chunks.length === 2 &&
+    isCanonicalSignature(chunks[0]) &&
+    isCanonicalPubKey(chunks[1])
 }
 
-function isPubKeyOutput (script) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
+function isPubKeyHashOutput (chunks) {
+  chunks = coerceChunks(chunks)
 
-  return script.chunks.length === 2 &&
-    isCanonicalPubKey(script.chunks[0]) &&
-    script.chunks[1] === ops.OP_CHECKSIG
+  return chunks.length === 5 &&
+    chunks[0] === ops.OP_DUP &&
+    chunks[1] === ops.OP_HASH160 &&
+    Buffer.isBuffer(chunks[2]) &&
+    chunks[2].length === 20 &&
+    chunks[3] === ops.OP_EQUALVERIFY &&
+    chunks[4] === ops.OP_CHECKSIG
 }
 
-function isScriptHashInput (script, allowIncomplete) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
+function isPubKeyInput (chunks) {
+  chunks = coerceChunks(chunks)
 
-  if (script.chunks.length < 2) return false
+  return chunks.length === 1 &&
+    isCanonicalSignature(chunks[0])
+}
 
-  var lastChunk = script.chunks[script.chunks.length - 1]
+function isPubKeyOutput (chunks) {
+  chunks = coerceChunks(chunks)
+
+  return chunks.length === 2 &&
+    isCanonicalPubKey(chunks[0]) &&
+    chunks[1] === ops.OP_CHECKSIG
+}
+
+function isScriptHashInput (chunks, allowIncomplete) {
+  chunks = coerceChunks(chunks)
+  if (chunks.length < 2) return false
+
+  var lastChunk = chunks[chunks.length - 1]
   if (!Buffer.isBuffer(lastChunk)) return false
 
-  var scriptSig = Script.fromChunks(script.chunks.slice(0, -1)).buffer
-  var redeemScript = lastChunk
+  var scriptSigChunks = chunks.slice(0, -1)
+  var redeemScriptChunks = Script.decompile(lastChunk)
 
   // is redeemScript a valid script?
-  if (Script.fromBuffer(redeemScript).chunks.length === 0) return false
+  if (redeemScriptChunks.length === 0) return false
 
-  return classifyInput(scriptSig, allowIncomplete) === classifyOutput(redeemScript)
+  return classifyInput(scriptSigChunks, allowIncomplete) === classifyOutput(redeemScriptChunks)
 }
 
-function isScriptHashOutput (script) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
+function isScriptHashOutput (chunks) {
+  chunks = coerceChunks(chunks)
 
-  return script.chunks.length === 3 &&
-    script.chunks[0] === ops.OP_HASH160 &&
-    Buffer.isBuffer(script.chunks[1]) &&
-    script.chunks[1].length === 20 &&
-    script.chunks[2] === ops.OP_EQUAL
+  return chunks.length === 3 &&
+    chunks[0] === ops.OP_HASH160 &&
+    Buffer.isBuffer(chunks[1]) &&
+    chunks[1].length === 20 &&
+    chunks[2] === ops.OP_EQUAL
 }
 
 // allowIncomplete is to account for combining signatures
 // See https://github.com/bitcoin/bitcoin/blob/f425050546644a36b0b8e0eb2f6934a3e0f6f80f/src/script/sign.cpp#L195-L197
-function isMultisigInput (script, allowIncomplete) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
-
-  if (script.chunks.length < 2) return false
-  if (script.chunks[0] !== ops.OP_0) return false
+function isMultisigInput (chunks, allowIncomplete) {
+  chunks = coerceChunks(chunks)
+  if (chunks.length < 2) return false
+  if (chunks[0] !== ops.OP_0) return false
 
   if (allowIncomplete) {
-    return script.chunks.slice(1).every(function (chunk) {
+    return chunks.slice(1).every(function (chunk) {
       return chunk === ops.OP_0 || isCanonicalSignature(chunk)
     })
   }
 
-  return script.chunks.slice(1).every(isCanonicalSignature)
+  return chunks.slice(1).every(isCanonicalSignature)
 }
 
-function isMultisigOutput (script) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
+function isMultisigOutput (chunks) {
+  chunks = coerceChunks(chunks)
+  if (chunks.length < 4) return false
+  if (chunks[chunks.length - 1] !== ops.OP_CHECKMULTISIG) return false
 
-  if (script.chunks.length < 4) return false
-  if (script.chunks[script.chunks.length - 1] !== ops.OP_CHECKMULTISIG) return false
-
-  var mOp = script.chunks[0]
+  var mOp = chunks[0]
   if (mOp === ops.OP_0) return false
   if (mOp < ops.OP_1) return false
   if (mOp > ops.OP_16) return false
 
-  var nOp = script.chunks[script.chunks.length - 2]
+  var nOp = chunks[chunks.length - 2]
   if (nOp === ops.OP_0) return false
   if (nOp < ops.OP_1) return false
   if (nOp > ops.OP_16) return false
@@ -147,47 +144,43 @@ function isMultisigOutput (script) {
   var n = nOp - (ops.OP_1 - 1)
   if (n < m) return false
 
-  var pubKeys = script.chunks.slice(1, -2)
+  var pubKeys = chunks.slice(1, -2)
   if (n < pubKeys.length) return false
 
   return pubKeys.every(isCanonicalPubKey)
 }
 
-function isNullDataOutput (script) {
-  typeforce(types.Buffer, script)
-  script = Script.fromBuffer(script)
-
-  return script.chunks[0] === ops.OP_RETURN
+function isNullDataOutput (chunks) {
+  chunks = coerceChunks(chunks)
+  return chunks[0] === ops.OP_RETURN
 }
 
-function classifyOutput (script) {
-  typeforce(types.Buffer, script)
-
-  if (isPubKeyHashOutput(script)) {
+function classifyOutput (chunks) {
+  chunks = coerceChunks(chunks)
+  if (isPubKeyHashOutput(chunks)) {
     return 'pubkeyhash'
-  } else if (isScriptHashOutput(script)) {
+  } else if (isScriptHashOutput(chunks)) {
     return 'scripthash'
-  } else if (isMultisigOutput(script)) {
+  } else if (isMultisigOutput(chunks)) {
     return 'multisig'
-  } else if (isPubKeyOutput(script)) {
+  } else if (isPubKeyOutput(chunks)) {
     return 'pubkey'
-  } else if (isNullDataOutput(script)) {
+  } else if (isNullDataOutput(chunks)) {
     return 'nulldata'
   }
 
   return 'nonstandard'
 }
 
-function classifyInput (script, allowIncomplete) {
-  typeforce(types.Buffer, script)
-
-  if (isPubKeyHashInput(script)) {
+function classifyInput (chunks, allowIncomplete) {
+  chunks = coerceChunks(chunks)
+  if (isPubKeyHashInput(chunks)) {
     return 'pubkeyhash'
-  } else if (isMultisigInput(script, allowIncomplete)) {
+  } else if (isMultisigInput(chunks, allowIncomplete)) {
     return 'multisig'
-  } else if (isScriptHashInput(script, allowIncomplete)) {
+  } else if (isScriptHashInput(chunks, allowIncomplete)) {
     return 'scripthash'
-  } else if (isPubKeyInput(script)) {
+  } else if (isPubKeyInput(chunks)) {
     return 'pubkey'
   }
 
@@ -197,34 +190,21 @@ function classifyInput (script, allowIncomplete) {
 // Standard Script Templates
 // {pubKey} OP_CHECKSIG
 function pubKeyOutput (pubKey) {
-  return Script.fromChunks([
-    pubKey,
-    ops.OP_CHECKSIG
-  ]).buffer
+  return Script.compile([pubKey, ops.OP_CHECKSIG])
 }
 
 // OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG
-function pubKeyHashOutput (hash) {
-  typeforce(types.Hash160bit, hash)
+function pubKeyHashOutput (pubKeyHash) {
+  typeforce(typeforce.Buffer, pubKeyHash)
 
-  return Script.fromChunks([
-    ops.OP_DUP,
-    ops.OP_HASH160,
-    hash,
-    ops.OP_EQUALVERIFY,
-    ops.OP_CHECKSIG
-  ]).buffer
+  return Script.compile([ops.OP_DUP, ops.OP_HASH160, pubKeyHash, ops.OP_EQUALVERIFY, ops.OP_CHECKSIG])
 }
 
 // OP_HASH160 {scriptHash} OP_EQUAL
-function scriptHashOutput (hash) {
-  typeforce(types.Hash160bit, hash)
+function scriptHashOutput (scriptHash) {
+  typeforce(typeforce.Buffer, scriptHash)
 
-  return Script.fromChunks([
-    ops.OP_HASH160,
-    hash,
-    ops.OP_EQUAL
-  ]).buffer
+  return Script.compile([ops.OP_HASH160, scriptHash, ops.OP_EQUAL])
 }
 
 // m [pubKeys ...] n OP_CHECKMULTISIG
@@ -234,46 +214,47 @@ function multisigOutput (m, pubKeys) {
   var n = pubKeys.length
   if (n < m) throw new Error('Not enough pubKeys provided')
 
-  return Script.fromChunks([].concat(
+  return Script.compile([].concat(
     (ops.OP_1 - 1) + m,
     pubKeys,
     (ops.OP_1 - 1) + n,
     ops.OP_CHECKMULTISIG
-  )).buffer
+  ))
 }
 
 // {signature}
 function pubKeyInput (signature) {
   typeforce(types.Buffer, signature)
 
-  return Script.fromChunks([signature]).buffer
+  return Script.compile([signature])
 }
 
 // {signature} {pubKey}
 function pubKeyHashInput (signature, pubKey) {
   typeforce(types.tuple(types.Buffer, types.Buffer), arguments)
 
-  return Script.fromChunks([signature, pubKey]).buffer
+  return Script.compile([signature, pubKey])
 }
 
 // <scriptSig> {serialized scriptPubKey script}
-function scriptHashInput (scriptSig, scriptPubKey) {
-  var scriptSigChunks = Script.fromBuffer(scriptSig).chunks
+function scriptHashInput (scriptSig, scriptPubKeyBuffer) {
+  scriptSig = coerceChunks(scriptSig)
+  scriptPubKeyBuffer = coerceBuffer(scriptPubKeyBuffer)
 
-  return Script.fromChunks([].concat(
-    scriptSigChunks,
-    scriptPubKey
-  )).buffer
+  return Script.compile([].concat(
+    scriptSig,
+    scriptPubKeyBuffer
+  ))
 }
 
 // OP_0 [signatures ...]
 function multisigInput (signatures, scriptPubKey) {
   if (scriptPubKey) {
     if (!isMultisigOutput(scriptPubKey)) throw new Error('Expected multisig scriptPubKey')
-    scriptPubKey = Script.fromBuffer(scriptPubKey)
+    scriptPubKey = coerceChunks(scriptPubKey)
 
-    var mOp = scriptPubKey.chunks[0]
-    var nOp = scriptPubKey.chunks[scriptPubKey.chunks.length - 2]
+    var mOp = scriptPubKey[0]
+    var nOp = scriptPubKey[scriptPubKey.length - 2]
     var m = mOp - (ops.OP_1 - 1)
     var n = nOp - (ops.OP_1 - 1)
 
@@ -281,11 +262,11 @@ function multisigInput (signatures, scriptPubKey) {
     if (signatures.length > n) throw new Error('Too many signatures provided')
   }
 
-  return Script.fromChunks([].concat(ops.OP_0, signatures)).buffer
+  return Script.compile([].concat(ops.OP_0, signatures))
 }
 
 function nullDataOutput (data) {
-  return Script.fromChunks([ops.OP_RETURN, data]).buffer
+  return Script.compile([ops.OP_RETURN, data])
 }
 
 module.exports = {
diff --git a/src/transaction.js b/src/transaction.js
index 0933589..b5a289e 100644
--- a/src/transaction.js
+++ b/src/transaction.js
@@ -193,7 +193,9 @@ Transaction.prototype.hashForSignature = function (inIndex, prevOutScript, hashT
 
   // in case concatenating two scripts ends up with two codeseparators,
   // or an extra one at the end, this prevents all those possible incompatibilities.
-  var hashScript = Script.fromBuffer(prevOutScript).without(opcodes.OP_CODESEPARATOR).buffer
+  var hashScript = Script.compile(Script.decompile(prevOutScript).filter(function (x) {
+    return x !== opcodes.OP_CODESEPARATOR
+  }))
   var i
 
   // blank out other inputs' signatures
diff --git a/src/transaction_builder.js b/src/transaction_builder.js
index fd6ab38..8683699 100644
--- a/src/transaction_builder.js
+++ b/src/transaction_builder.js
@@ -13,7 +13,7 @@ var Transaction = require('./transaction')
 function extractInput (txIn) {
   var redeemScript
   var scriptSig = txIn.script
-  var scriptSigChunks = Script.fromBuffer(scriptSig).chunks
+  var scriptSigChunks = Script.decompile(scriptSig)
 
   var prevOutScript
   var prevOutType = scripts.classifyInput(scriptSig, true)
@@ -24,7 +24,7 @@ function extractInput (txIn) {
     redeemScript = scriptSigChunks.slice(-1)[0]
     prevOutScript = scripts.scriptHashOutput(bcrypto.hash160(redeemScript))
 
-    scriptSig = Script.fromChunks(scriptSigChunks.slice(0, -1)).buffer
+    scriptSig = Script.compile(scriptSigChunks.slice(0, -1))
     scriptSigChunks = scriptSigChunks.slice(0, -1)
 
     scriptType = scripts.classifyInput(scriptSig, true)
@@ -51,7 +51,7 @@ function extractInput (txIn) {
       signatures = [parsed.signature]
 
       if (redeemScript) {
-        pubKeys = Script.fromBuffer(redeemScript).chunks.slice(0, 1)
+        pubKeys = Script.decompile(redeemScript).slice(0, 1)
       }
 
       break
@@ -67,7 +67,7 @@ function extractInput (txIn) {
       })
 
       if (redeemScript) {
-        pubKeys = Script.fromBuffer(redeemScript).chunks.slice(1, -2)
+        pubKeys = Script.decompile(redeemScript).slice(1, -2)
       }
 
       break
@@ -142,8 +142,8 @@ TransactionBuilder.prototype.addInput = function (txHash, vout, sequence, prevOu
 
   var input = {}
   if (prevOutScript) {
-    var prevOutType = scripts.classifyOutput(prevOutScript)
-    var prevOutScriptChunks = Script.fromBuffer(prevOutScript).chunks
+    var prevOutScriptChunks = Script.decompile(prevOutScript)
+    var prevOutType = scripts.classifyOutput(prevOutScriptChunks)
 
     // if we can, extract pubKey information
     switch (prevOutType) {
@@ -313,14 +313,14 @@ TransactionBuilder.prototype.sign = function (index, keyPair, redeemScript, hash
       if (input.prevOutScript) {
         if (input.prevOutType !== 'scripthash') throw new Error('PrevOutScript must be P2SH')
 
-        var scriptHash = Script.fromBuffer(input.prevOutScript).chunks[1]
+        var scriptHash = Script.decompile(input.prevOutScript)[1]
         if (!bufferutils.equal(scriptHash, bcrypto.hash160(redeemScript))) throw new Error('RedeemScript does not match ' + scriptHash.toString('hex'))
       }
 
       var scriptType = scripts.classifyOutput(redeemScript)
       if (!canSignTypes[scriptType]) throw new Error('RedeemScript not supported (' + scriptType + ')')
 
-      var redeemScriptChunks = Script.fromBuffer(redeemScript).chunks
+      var redeemScriptChunks = Script.decompile(redeemScript)
       var pubKeys = []
       switch (scriptType) {
         case 'multisig':
diff --git a/test/address.js b/test/address.js
index ab37ed8..bdf52a6 100644
--- a/test/address.js
+++ b/test/address.js
@@ -31,7 +31,7 @@ describe('Address', function () {
   describe('fromOutputScript', function () {
     fixtures.valid.forEach(function (f) {
       it('parses ' + f.script.slice(0, 30) + '... (' + f.network + ')', function () {
-        var script = Script.fromASM(f.script).buffer
+        var script = Script.fromASM(f.script)
         var address = Address.fromOutputScript(script, networks[f.network])
 
         assert.strictEqual(address, f.base58check)
@@ -40,7 +40,7 @@ describe('Address', function () {
 
     fixtures.invalid.fromOutputScript.forEach(function (f) {
       it('throws when ' + f.script.slice(0, 30) + '... ' + f.exception, function () {
-        var script = Script.fromASM(f.script).buffer
+        var script = Script.fromASM(f.script)
 
         assert.throws(function () {
           Address.fromOutputScript(script)
@@ -66,7 +66,7 @@ describe('Address', function () {
       it('exports ' + f.script.slice(0, 30) + '... (' + f.network + ')', function () {
         var script = Address.toOutputScript(f.base58check, network)
 
-        assert.strictEqual(Script.fromBuffer(script).toASM(), f.script)
+        assert.strictEqual(Script.toASM(script), f.script)
       })
     })
 
diff --git a/test/bitcoin.core.js b/test/bitcoin.core.js
index 769a612..49d160a 100644
--- a/test/bitcoin.core.js
+++ b/test/bitcoin.core.js
@@ -227,8 +227,9 @@ describe('Bitcoin-core', function () {
         var transaction = Transaction.fromHex(txHex)
         assert.strictEqual(transaction.toHex(), txHex)
 
-        var script = Script.fromHex(scriptHex).buffer
-        assert.strictEqual(Script.fromBuffer(script).toHex(), scriptHex)
+        var script = new Buffer(scriptHex, 'hex')
+        var scriptChunks = Script.decompile(script)
+        assert.strictEqual(Script.compile(scriptChunks).toString('hex'), scriptHex)
 
         var hash = transaction.hashForSignature(inIndex, script, hashType)
         assert.deepEqual(hash, expectedHash)
diff --git a/test/script.js b/test/script.js
index 8c20403..0a885b5 100644
--- a/test/script.js
+++ b/test/script.js
@@ -2,30 +2,12 @@
 /* eslint-disable no-new */
 
 var assert = require('assert')
-var opcodes = require('../src/opcodes')
-
 var Script = require('../src/script')
+var OPS = require('../src/opcodes')
 
 var fixtures = require('./fixtures/script.json')
 
 describe('Script', function () {
-  describe('constructor', function () {
-    it('accepts valid parameters', function () {
-      var buffer = new Buffer([1])
-      var chunks = [1]
-      var script = new Script(buffer, chunks)
-
-      assert.strictEqual(script.buffer, buffer)
-      assert.strictEqual(script.chunks, chunks)
-    })
-
-    it('throws an error when input is not an array', function () {
-      assert.throws(function () {
-        new Script({})
-      }, /Expected Buffer, got/)
-    })
-  })
-
   describe('fromASM/toASM', function () {
     fixtures.valid.forEach(function (f) {
       if (!f.asm) return
@@ -33,53 +15,23 @@ describe('Script', function () {
       it('decodes/encodes ' + f.description, function () {
         var script = Script.fromASM(f.asm)
 
-        assert.strictEqual(script.toASM(), f.asm)
-        assert.strictEqual(script.buffer.toString('hex'), f.hex)
+        assert.strictEqual(Script.toASM(script), f.asm)
       })
     })
   })
 
-  describe('fromHex/toHex', function () {
-    fixtures.valid.forEach(function (f) {
-      it('decodes/encodes ' + f.description, function () {
-        var script = Script.fromHex(f.hex)
-
-        assert.strictEqual(script.toASM(), f.asm)
-        assert.strictEqual(script.buffer.toString('hex'), f.hex)
-      })
-    })
-  })
-
-  describe('fromChunks', function () {
+  describe('compile', function () {
     it('should match expected behaviour', function () {
       var hash = new Buffer(32)
       hash.fill(0)
 
-      var script = Script.fromChunks([
-        opcodes.OP_HASH160,
+      var script = Script.compile([
+        OPS.OP_HASH160,
         hash,
-        opcodes.OP_EQUAL
+        OPS.OP_EQUAL
       ])
 
-      assert.strictEqual(script.buffer.toString('hex'), 'a920000000000000000000000000000000000000000000000000000000000000000087')
-    })
-  })
-
-  describe('without', function () {
-    var hex = 'a914e8c300c87986efa94c37c0519929019ef86eb5b487'
-    var script = Script.fromHex(hex)
-
-    it('should return a script without the given value', function () {
-      var subScript = script.without(opcodes.OP_HASH160)
-
-      assert.strictEqual(subScript.buffer.toString('hex'), '14e8c300c87986efa94c37c0519929019ef86eb5b487')
-    })
-
-    it('shouldnt mutate the original script', function () {
-      var subScript = script.without(opcodes.OP_EQUAL)
-
-      assert.notEqual(subScript.buffer.toString('hex'), hex)
-      assert.strictEqual(script.buffer.toString('hex'), hex)
+      assert.strictEqual(script.toString('hex'), 'a920000000000000000000000000000000000000000000000000000000000000000087')
     })
   })
 })
diff --git a/test/scripts.js b/test/scripts.js
index 64635ce..bdb9264 100644
--- a/test/scripts.js
+++ b/test/scripts.js
@@ -19,7 +19,7 @@ describe('Scripts', function () {
       if (!f.scriptSig) return
 
       it('classifies ' + f.scriptSig + ' as ' + f.type, function () {
-        var script = Script.fromASM(f.scriptSig).buffer
+        var script = Script.fromASM(f.scriptSig)
         var type = scripts.classifyInput(script)
 
         assert.strictEqual(type, f.type)
@@ -31,7 +31,7 @@ describe('Scripts', function () {
       if (!f.typeIncomplete) return
 
       it('classifies incomplete ' + f.scriptSig + ' as ' + f.typeIncomplete, function () {
-        var script = Script.fromASM(f.scriptSig).buffer
+        var script = Script.fromASM(f.scriptSig)
         var type = scripts.classifyInput(script, true)
 
         assert.strictEqual(type, f.typeIncomplete)
@@ -44,7 +44,7 @@ describe('Scripts', function () {
       if (!f.scriptPubKey) return
 
       it('classifies ' + f.scriptPubKey + ' as ' + f.type, function () {
-        var script = Script.fromASM(f.scriptPubKey).buffer
+        var script = Script.fromASM(f.scriptPubKey)
         var type = scripts.classifyOutput(script)
 
         assert.strictEqual(type, f.type)
@@ -67,9 +67,9 @@ describe('Scripts', function () {
           var script
 
           if (f.scriptSig) {
-            script = Script.fromASM(f.scriptSig).buffer
+            script = Script.fromASM(f.scriptSig)
           } else {
-            script = Script.fromHex(f.scriptSigHex).buffer
+            script = Script.fromHex(f.scriptSigHex)
           }
 
           it('returns ' + expected + ' for ' + f.scriptSig, function () {
@@ -94,9 +94,9 @@ describe('Scripts', function () {
             var script
 
             if (f.scriptSig) {
-              script = Script.fromASM(f.scriptSig).buffer
+              script = Script.fromASM(f.scriptSig)
             } else {
-              script = Script.fromHex(f.scriptSigHex).buffer
+              script = Script.fromHex(f.scriptSigHex)
             }
 
             assert.strictEqual(inputFn(script), false)
@@ -111,7 +111,7 @@ describe('Scripts', function () {
 
         if (outputFn && f.scriptPubKey) {
           it('returns ' + expected + ' for ' + f.scriptPubKey, function () {
-            var script = Script.fromASM(f.scriptPubKey).buffer
+            var script = Script.fromASM(f.scriptPubKey)
 
             assert.strictEqual(outputFn(script), expected)
           })
@@ -123,7 +123,7 @@ describe('Scripts', function () {
       fixtures.invalid[outputFnName].forEach(function (f) {
         if (outputFn && f.scriptPubKey) {
           it('returns false for ' + f.description + ' (' + f.scriptPubKey + ')', function () {
-            var script = Script.fromASM(f.scriptPubKey).buffer
+            var script = Script.fromASM(f.scriptPubKey)
 
             assert.strictEqual(outputFn(script), false)
           })
@@ -140,7 +140,7 @@ describe('Scripts', function () {
         var signature = new Buffer(f.signature, 'hex')
 
         var scriptSig = scripts.pubKeyInput(signature)
-        assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig)
+        assert.strictEqual(Script.toASM(scriptSig), f.scriptSig)
       })
     })
   })
@@ -152,7 +152,8 @@ describe('Scripts', function () {
       it('returns ' + f.scriptPubKey, function () {
         var pubKey = new Buffer(f.pubKey, 'hex')
         var scriptPubKey = scripts.pubKeyOutput(pubKey)
-        assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
+
+        assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
   })
@@ -167,7 +168,7 @@ describe('Scripts', function () {
         var signature = new Buffer(f.signature, 'hex')
 
         var scriptSig = scripts.pubKeyHashInput(signature, pubKey)
-        assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig)
+        assert.strictEqual(Script.toASM(scriptSig), f.scriptSig)
       })
     })
   })
@@ -181,7 +182,7 @@ describe('Scripts', function () {
 
       it('returns ' + f.scriptPubKey, function () {
         var scriptPubKey = scripts.pubKeyHashOutput(pubKeyHash)
-        assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
+        assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
   })
@@ -196,12 +197,12 @@ describe('Scripts', function () {
         })
 
         var scriptSig = scripts.multisigInput(signatures)
-        assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig)
+        assert.strictEqual(Script.toASM(scriptSig), f.scriptSig)
       })
     })
 
     fixtures.invalid.multisigInput.forEach(function (f) {
-      var scriptPubKey = Script.fromASM(f.scriptPubKey).buffer
+      var scriptPubKey = Script.fromASM(f.scriptPubKey)
 
       it('throws on ' + f.exception, function () {
         var signatures = f.signatures.map(function (signature) {
@@ -223,7 +224,7 @@ describe('Scripts', function () {
       var scriptPubKey = scripts.multisigOutput(pubKeys.length, pubKeys)
 
       it('returns ' + f.scriptPubKey, function () {
-        assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
+        assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
 
@@ -244,16 +245,17 @@ describe('Scripts', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'scripthash') return
 
-      var redeemScript = Script.fromASM(f.redeemScript).buffer
-      var redeemScriptSig = Script.fromASM(f.redeemScriptSig).buffer
+      var redeemScript = Script.fromASM(f.redeemScript)
+      var redeemScriptSig = Script.fromASM(f.redeemScriptSig)
 
       it('returns ' + f.scriptSig, function () {
         var scriptSig = scripts.scriptHashInput(redeemScriptSig, redeemScript)
 
         if (f.scriptSig) {
-          assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig)
+          assert.strictEqual(Script.toASM(scriptSig), f.scriptSig)
+
         } else {
-          assert.strictEqual(Script.fromBuffer(scriptSig).toHex(), f.scriptSigHex)
+          assert.strictEqual(scriptSig.toString('hex'), f.scriptSigHex)
         }
       })
     })
@@ -265,10 +267,10 @@ describe('Scripts', function () {
       if (!f.scriptPubKey) return
 
       it('returns ' + f.scriptPubKey, function () {
-        var redeemScript = Script.fromASM(f.redeemScript).buffer
+        var redeemScript = Script.compile(Script.fromASM(f.redeemScript))
         var scriptPubKey = scripts.scriptHashOutput(bcrypto.hash160(redeemScript))
 
-        assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
+        assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
   })
@@ -281,7 +283,7 @@ describe('Scripts', function () {
       var scriptPubKey = scripts.nullDataOutput(data)
 
       it('returns ' + f.scriptPubKey, function () {
-        assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
+        assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
   })
diff --git a/test/transaction.js b/test/transaction.js
index 6ac9bb8..af8639d 100644
--- a/test/transaction.js
+++ b/test/transaction.js
@@ -20,8 +20,9 @@ describe('Transaction', function () {
       if (txIn.data) {
         var data = new Buffer(txIn.data, 'hex')
         script = data
+
       } else if (txIn.script) {
-        script = Script.fromASM(txIn.script).buffer
+        script = Script.compile(Script.fromASM(txIn.script))
       }
 
       tx.addInput(txHash, txIn.index, txIn.sequence, script)
@@ -33,8 +34,9 @@ describe('Transaction', function () {
       if (txOut.data) {
         var data = new Buffer(txOut.data, 'hex')
         script = data
+
       } else if (txOut.script) {
-        script = Script.fromASM(txOut.script).buffer
+        script = Script.compile(Script.fromASM(txOut.script))
       }
 
       tx.addOutput(script, txOut.value)
diff --git a/test/transaction_builder.js b/test/transaction_builder.js
index 0367aac..8737fdf 100644
--- a/test/transaction_builder.js
+++ b/test/transaction_builder.js
@@ -22,14 +22,14 @@ function construct (f, sign) {
     var prevTxScript
 
     if (input.prevTxScript) {
-      prevTxScript = Script.fromASM(input.prevTxScript).buffer
+      prevTxScript = Script.compile(Script.fromASM(input.prevTxScript))
     }
 
     txb.addInput(input.txId, input.vout, input.sequence, prevTxScript)
   })
 
   f.outputs.forEach(function (output) {
-    var script = Script.fromASM(output.script).buffer
+    var script = Script.compile(Script.fromASM(output.script))
 
     txb.addOutput(script, output.value)
   })
@@ -41,7 +41,7 @@ function construct (f, sign) {
         var redeemScript
 
         if (sign.redeemScript) {
-          redeemScript = Script.fromASM(sign.redeemScript).buffer
+          redeemScript = Script.compile(Script.fromASM(sign.redeemScript))
         }
 
         txb.sign(index, keyPair, redeemScript, sign.hashType)
@@ -200,7 +200,7 @@ describe('TransactionBuilder', function () {
             var redeemScript
 
             if (sign.redeemScript) {
-              redeemScript = Script.fromASM(sign.redeemScript).buffer
+              redeemScript = Script.compile(Script.fromASM(sign.redeemScript))
             }
 
             if (!sign.throws) {
@@ -262,7 +262,7 @@ describe('TransactionBuilder', function () {
         var network = NETWORKS[f.network]
 
         f.inputs.forEach(function (input, i) {
-          var redeemScript = Script.fromASM(input.redeemScript).buffer
+          var redeemScript = Script.compile(Script.fromASM(input.redeemScript))
 
           input.signs.forEach(function (sign) {
             // rebuild the transaction each-time after the first
@@ -272,11 +272,11 @@ describe('TransactionBuilder', function () {
                 var scriptSig = tx.ins[i].script
 
                 // ignore OP_0 on the front, ignore redeemScript
-                var signatures = Script.fromBuffer(scriptSig).chunks.slice(1, -1).filter(function (x) { return x !== ops.OP_0 })
+                var signatures = Script.decompile(scriptSig).slice(1, -1).filter(function (x) { return x !== ops.OP_0 })
 
                 // rebuild/replace the scriptSig without them
                 var replacement = scripts.scriptHashInput(scripts.multisigInput(signatures), redeemScript)
-                assert.strictEqual(Script.fromBuffer(replacement).toASM(), sign.scriptSigFiltered)
+                assert.strictEqual(Script.toASM(replacement), sign.scriptSigFiltered)
 
                 tx.ins[i].script = replacement
               }
@@ -292,7 +292,7 @@ describe('TransactionBuilder', function () {
             tx = txb.buildIncomplete()
 
             // now verify the serialized scriptSig is as expected
-            assert.strictEqual(Script.fromBuffer(tx.ins[i].script).toASM(), sign.scriptSig)
+            assert.strictEqual(Script.toASM(tx.ins[i].script), sign.scriptSig)
           })
         })
 
@@ -309,7 +309,7 @@ describe('TransactionBuilder', function () {
 
       txb = TransactionBuilder.fromTransaction(lameTx, network)
 
-      var redeemScript = Script.fromASM('OP_2 0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 04c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee51ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a 04f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672 OP_3 OP_CHECKMULTISIG').buffer
+      var redeemScript = Script.compile(Script.fromASM('OP_2 0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 04c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee51ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a 04f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672 OP_3 OP_CHECKMULTISIG'))
 
       var keyPair = ECPair.fromWIF('91avARGdfge8E4tZfYLoxeJ5sGBdNJQH4kvjJoQFacbgx3cTMqe', network)
       txb.sign(0, keyPair, redeemScript)