diff --git a/packages/asm/README.md b/packages/asm/README.md
new file mode 100644
index 000000000..236f83508
--- /dev/null
+++ b/packages/asm/README.md
@@ -0,0 +1,182 @@
+ASM Utilities
+=============
+
+**Experimental** Do not use this package in production (yet)
+
+-----
+
+A semi-advanced EVM assembler.
+
+**Features**
+
+- Nested code scoping allows relative jumps
+- Execute JavaScript meta-programming inline
+- Self-padding data blocks
+- TODO: optional Position-Independant-Code
+- MIT licensed.
+
+Command-Line Interface
+======================
+
+@TODO: Add this to the CLI package.
+
+```
+/home/ethers> ethers-asm [ --disassemble ] [ FILENAME ]
+```
+
+Syntax
+======
+
+Comments
+--------
+
+Any text that occurs after a semi-colon (i.e. `;`) is treated as a comment.
+
+```
+; This is a comment. If a comments spans multiple
+; lines, it needs multiple semi-colons.
+
+@foobar:          ; Here is another comment
+```
+
+Opcodes
+-------
+
+Each OPCODE may be specified using either the **functional notations** or
+the **stack notation**.
+
+### Functional Notation
+
+This is the recommended syntax for opcodes as the assembler will perform
+the additional step of verifying the correct number of operands are passed
+in for the giver operation.
+
+```
+blockhash(sub(number, 1))
+```
+
+### Stack Notation
+
+This method is often useful when adapting other existing disassembled
+bytecode.
+
+```
+1
+number
+sub
+blockhash
+```
+
+Labels
+------
+
+Labels are used for control flow, by providing an achor that can be used
+by `JUMP` and `JUMPI`.
+
+A label is relative to its **scope** and cannot be references outside of
+its exact scope and automatically injects a `JUMPDEST` opcode.
+
+```
+@top:
+    jump($top)
+```
+
+Data Blocks
+-----------
+
+Sometimes verbatim data is desired, for example, embedding strings or
+look-up tables.
+
+This can be any number of **hexstrings**, **decimal bytes** or **evals**.
+
+A **data block** is automatically padded to ensure that any data that is
+coincidentally a PUSH opcode does not impact code or data outside the
+data block.
+
+A **data** exposes two variables: the offset (in the current scope) `$foo`
+and `#foo`, the length of the data. The offset may only be accessed from an
+ancestor scope while the length may be accessed from any scope.
+
+```
+codecopy(0x20, $foobar, #foobar)  ; Copy the data to memory address 32
+
+@foobar [
+    0x1234                        ; This is exactly 2 bytes (i.e. 4 nibbles)
+    42 65 73                      ; These are decmial values (3 bytes)
+]
+```
+
+Scopes
+------
+
+A scope is a new frame of reference, which offsets will be based on. This
+makes embedding code within code easier, since the jump destinations and
+**data blocks** can be accessed relatively.
+
+The top scope is named `_`.
+
+```
+
+// This runs the deployment
+sstore(0, ${{ toUtf8Bytes("Hello World") }})
+codecopy(0, $deployment, #deployment)
+return (0, #deployment)
+
+@contract {
+  @label:
+      jump($label)    
+}
+```
+
+Evaluation and Execution
+------------------------
+
+It is often useful to be able to modify a program in more advanced ways
+at code generation time. JavaScript code can be executed in a `{{! code }}``
+which does not place any output in the code, but can be used to define
+functions and variables and code can be evaluated in a ``{{= code }}``
+which will place the output of the *code* into the assembled output, following
+the same rules as **Data Blocks**.
+
+```
+{{!
+    function foo() { return 42; }
+}}
+
+{{= foo() }}
+1
+add
+```
+
+Notes
+=====
+
+Because of the nature of script evaluation, it is possible to create
+programs which cannot actually be assembled. The assembler will give
+up after 512 attempts to find a stable organization of the code.
+
+For example, this code contains a scope named `junk`, which is a `CALLER`
+statement followed by a data block equal to the bytecode of `junk`. Since
+this is recursive, there is never any way for this to be satisfied. This is
+similar to VHDL programs where it is possible to simulate recursion, but
+impossible to synthesize recursive hardware.
+
+```
+@junk {
+    caller
+    @thisIsRecursive[
+       {{= junk }}
+    ]
+}
+```
+
+Building
+========
+
+If you make changes to the `grammar.jison` file, make sure to run the `npm generate`
+command to re-build the AST parser.
+
+License
+=======
+
+MIT License.
diff --git a/packages/asm/generate.js b/packages/asm/generate.js
new file mode 100644
index 000000000..5262923bc
--- /dev/null
+++ b/packages/asm/generate.js
@@ -0,0 +1,13 @@
+"use strict";
+
+const fs = require("fs");
+
+const jison = require("jison")
+
+const grammar = fs.readFileSync("grammar.jison").toString();
+
+const parser = new jison.Parser(grammar);
+
+const parserSource = parser.generate({ moduleName: "parser" });
+
+fs.writeFileSync("./lib/_parser.js", parserSource);
diff --git a/packages/asm/grammar.jison b/packages/asm/grammar.jison
new file mode 100644
index 000000000..5f4edf02c
--- /dev/null
+++ b/packages/asm/grammar.jison
@@ -0,0 +1,168 @@
+%lex
+
+%x script
+
+%%
+
+// Inline JavaScript State (gobble up all tokens including whitespace)
+
+"{{="                                          %{ this.begin("script"); return "SCRIPT_EVAL"; %}
+"{{!"                                          %{ this.begin("script"); return "SCRIPT_EXEC"; %}
+<script>([^\}]|\n|\}[^}])                      return "SCRIPT_TOKEN";
+<script>"}}"                                   this.popState()
+
+
+// Assembler State
+
+// Ignorables
+([;][^\n]*\n)                                  // Ignore comments
+(\s+)                                          // Ignore Whitespace
+
+// Identifiers (and opcodes)
+([A-Za-z][A-Za-z0-9]*)                         return "ID"
+
+// Lists
+"("                                            return "OPEN_PAREN"
+")"                                            return "CLOSE_PAREN"
+","                                            return "COMMA"
+
+// Labels prefixes
+([@][A-Za-z][A-Za-z0-9]*)                      return "AT_ID"
+([#][A-Za-z][A-Za-z0-9]*)                      return "HASH_ID"
+([$][A-Za-z][A-Za-z0-9]*)                      return "DOLLAR_ID"
+
+// Scope
+"{"                                            return "OPEN_BRACE"
+"}"                                            return "CLOSE_BRACE"
+":"                                            return "COLON"
+
+// Data
+"["                                            return "OPEN_BRACKET"
+"]"                                            return "CLOSE_BRACKET"
+
+// Literals
+(0x([0-9a-fA-F][0-9a-fA-F])*)                  return "HEX"
+([1-9][0-9]*|0)                                return "DECIMAL"
+//(0b[01]*)                                      return "BINARY"
+
+// Special
+<<EOF>>                                        return "EOF"
+                                               return "INVALID"
+
+/lex
+
+%start program
+
+%%
+
+program
+    : statement_list EOF
+        { return { type: "scope", name: "_", statements: $1, loc: getLoc(yy, null) }; }
+    ;
+
+javascript
+    : /* empty */
+       { $$ = ""; }
+    | SCRIPT_TOKEN javascript
+       { $$ = $1 + $2; }    
+    ;
+
+opcode_list
+    : opcode
+        { $$ = [ $1 ]; }
+    | opcode COMMA opcode_list
+        { {
+           const opcodes = $3.slice();
+           opcodes.unshift($1);
+           $$ = opcodes;
+        } }
+    ;
+
+opcode
+    : ID
+        { $$ = { type: "opcode", bare: true, mnemonic: $1, operands: [ ], loc: getLoc(yy, @1) }; }
+    | ID OPEN_PAREN CLOSE_PAREN
+        { $$ = { type: "opcode", mnemonic: $1, operands: [ ], loc: getLoc(yy, @1, @3) }; }
+    | ID OPEN_PAREN opcode_list CLOSE_PAREN
+        { $$ = { type: "opcode", mnemonic: $1, operands: $3, loc: getLoc(yy, @1, @4) }; }
+    | HASH_ID
+        { $$ = { type: "length", label: $1.substring(1), loc: getLoc(yy, @1) }; }
+    | DOLLAR_ID
+        { $$ = { type: "offset", label: $1.substring(1), loc: getLoc(yy, @1)  }; }
+    | HEX
+        { $$ = { type: "hex", value: $1, loc: getLoc(yy, @1)  }; }
+    | DECIMAL
+        { $$ = { type: "decimal", value: $1, loc: getLoc(yy, @1)  }; }
+    | SCRIPT_EVAL javascript
+        { $$ = { type: "eval", script: $2, loc: getLoc(yy, @1, @2)  }; }
+    ;
+
+hex_list
+    : /* empty */
+        { $$ = [ ]; }
+    | hex hex_list
+        { {
+            const hexes = $2.slice();;
+            hexes.unshift($1);
+            $$ = hexes;
+        } }
+    ;
+
+hex
+    : HEX
+        { $$ = { type: "hex", verbatim: true, value: $1, loc: getLoc(yy, @1) }; }
+    | DECIMAL
+        { {
+            const value = parseInt($1);
+            if (value >= 256) { throw new Error("decimal data values must be single bytes"); }
+            $$ = { type: "hex", verbatim: true, value: ("0x" + (value).toString(16)), loc: getLoc(yy, @1) };
+        } }
+    | SCRIPT_EVAL javascript
+        { $$ = { type: "eval", verbatim: true, script: $2, loc: getLoc(yy, @1, @2) }; }
+    ;
+
+statement_list
+    : /* empty */
+        { $$ = [ ]; }
+    | statement statement_list
+        { {
+            const statements = $2.slice();
+            statements.unshift($1);
+            $$ = statements;
+        } }
+    ;
+
+statement
+    : opcode
+    | AT_ID COLON
+        { $$ = { type: "label", name: $1.substring(1), loc: getLoc(yy, @1, @2)  }; }
+    | AT_ID OPEN_BRACE statement_list CLOSE_BRACE
+        { $$ = { type: "scope", name: $1.substring(1), statements: $3, loc: getLoc(yy, @1, @4) }; }
+    | AT_ID OPEN_BRACKET hex_list CLOSE_BRACKET
+        { $$ = { type: "data", name: $1.substring(1), data: $3, loc: getLoc(yy, @1, @4) }; }
+    | SCRIPT_EXEC javascript
+        { $$ = { type: "exec", script: $2, loc: getLoc(yy, @1, @2) }; }
+    ;
+
+%%
+
+function getLoc(yy, start, end) {
+    if (end == null) { end = start; }
+
+    let result = null;
+    if (start) {
+        result = {
+            first_line: start.first_line,
+            first_column: start.first_column,
+            last_line: end.last_line,
+            last_column: end.last_column
+        };
+    }
+
+    if (yy._ethersLocation) {
+        return yy._ethersLocation(result);
+    }
+
+    return Object.freeze(result);
+}
+
diff --git a/packages/asm/package.json b/packages/asm/package.json
new file mode 100644
index 000000000..a9879dcc6
--- /dev/null
+++ b/packages/asm/package.json
@@ -0,0 +1,35 @@
+{
+  "author": "Richard Moore <me@ricmoo.com>",
+  "dependencies": {
+    "ethers": ">=5.0.0-beta.171"
+  },
+  "description": "ASM libraries and tools for the Ethereum EVM.",
+  "devDependencies": {
+    "@types/node": "^12.7.4",
+    "jison": "^0.4.18"
+  },
+  "ethereum": "donations.ethers.eth",
+  "keywords": [
+    "Ethereum",
+    "asm",
+    "evm"
+  ],
+  "license": "MIT",
+  "main": "./lib/index.js",
+  "module": "./lib.esm/index.js",
+  "name": "@ethersproject/asm",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ethers-io/ethers.js.git"
+  },
+  "scripts": {
+    "generate": "node ./generate.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "tarballHash": "0x8c1c74059eaf59d10d94fcb2285fb2512a1fdf121ef5c3167e8afa16807bbbb3",
+  "types": "./lib/index.d.ts",
+  "version": "5.0.0-beta.148"
+}
diff --git a/packages/asm/src.ts/_parser.d.ts b/packages/asm/src.ts/_parser.d.ts
new file mode 100644
index 000000000..f62c84f1a
--- /dev/null
+++ b/packages/asm/src.ts/_parser.d.ts
@@ -0,0 +1,2 @@
+export function parse(source: string): any;
+export const parser: { yy: { [ key: string ]: any } };
diff --git a/packages/asm/src.ts/_version.ts b/packages/asm/src.ts/_version.ts
new file mode 100644
index 000000000..5245d5b12
--- /dev/null
+++ b/packages/asm/src.ts/_version.ts
@@ -0,0 +1 @@
+export const version = "asm/5.0.0-beta.148";
diff --git a/packages/asm/src.ts/assembler.ts b/packages/asm/src.ts/assembler.ts
new file mode 100644
index 000000000..374b7eb72
--- /dev/null
+++ b/packages/asm/src.ts/assembler.ts
@@ -0,0 +1,1035 @@
+"use strict";
+
+// @TODO:
+// - PIC
+// - warn on opcode non-function iff parameters
+// - warn return/revert non-empty, comment ; !assert(+1 @extra)
+// - $$
+// - In JS add config (positionIndependent)
+// - When checking name collisions, verify no collision in javascript
+
+import { dirname, resolve } from "path";
+import _module from "module";
+import vm from "vm";
+
+import { ethers } from "ethers";
+
+import { getOpcode, Opcode } from "./opcodes";
+
+import { parse as _parse, parser as _parser } from "./_parser";
+
+import { version } from "./_version";
+const logger = new ethers.utils.Logger(version);
+
+const Guard = { };
+
+function hexConcat(values: Array<Opcode | ethers.utils.BytesLike>): string {
+    return ethers.utils.hexlify(ethers.utils.concat(values.map((v) => {
+        if (v instanceof Opcode) { return [ v.value ]; }
+        return v;
+    })));
+}
+
+function repeat(char: string, length: number): string {
+    let result = char;
+    while (result.length < length) { result += result; }
+    return result.substring(0, length);
+}
+
+class Script {
+    readonly filename: string;
+    readonly context: any;
+    readonly contextObject: any;
+
+    private _context: { context: any };
+
+    constructor(filename: string, callback: (name: string, context: any) => any) {
+        ethers.utils.defineReadOnly(this, "filename", filename);
+
+        ethers.utils.defineReadOnly(this, "contextObject", this._baseContext(callback));
+        ethers.utils.defineReadOnly(this, "context", vm.createContext(this.contextObject));
+    }
+
+    _baseContext(callback: (name: string, context: any) => any): any {
+         return new Proxy({
+            __filename: this.filename,
+            __dirname: dirname(this.filename),
+
+            console: console,
+            Uint8Array: Uint8Array,
+
+            ethers: ethers,
+            utils: ethers.utils,
+
+            arrayify: ethers.utils.arrayify,
+            hexlify: ethers.utils.hexlify,
+            concat: hexConcat,
+
+            id: ethers.utils.id,
+            keccak256: ethers.utils.keccak256,
+            namehash: ethers.utils.namehash,
+            sha256: ethers.utils.sha256,
+
+            parseEther: ethers.utils.parseEther,
+            formatEther: ethers.utils.formatEther,
+            parseUnits: ethers.utils.parseUnits,
+            formatUnits: ethers.utils.formatUnits,
+
+            randomBytes: function(length: number): string {
+                return ethers.utils.hexlify(ethers.utils.randomBytes(length));
+            },
+
+            toUtf8Bytes: ethers.utils.toUtf8Bytes,
+            toUtf8String: ethers.utils.toUtf8String,
+            formatBytes32String: ethers.utils.formatBytes32String,
+            parseBytes32String: ethers.utils.parseBytes32String,
+
+            getOpcode: getOpcode,
+
+            sighash: function(signature: string): string {
+               return ethers.utils.id(ethers.utils.FunctionFragment.from(signature).format()).substring(0, 10);
+            },
+            topichash: function(signature: string): string {
+               return ethers.utils.id(ethers.utils.EventFragment.from(signature).format());
+            },
+
+            assemble: assemble,
+            disassemble: disassemble
+        }, {
+            get: (obj: any, key: string): any => {
+                if (obj[key]) { return obj[key]; }
+                if (!callback) { return undefined; }
+                return callback(key, this._context.context);
+            }
+        });
+    }
+
+
+    async evaluate(code: string, context?: any): Promise<string> {
+        if (this._context) { throw new Error("evaluation collision"); }
+        this._context = { context: context };
+
+        const script = new vm.Script(code, { filename: this.filename });
+
+        let result = script.runInContext(this.context);
+        if (result instanceof Promise) {
+            result = await result;
+        }
+
+        this._context = null;
+
+        return result;
+    }
+}
+
+let nextTag = 1;
+
+export type Location = {
+    offset: number;
+    length: number;
+    source: string;
+};
+
+export type AssembleVisitFunc = (node: Node, bytecode: string) => void;
+
+export type VisitFunc = (node: Node) => void;
+
+export abstract class Node {
+    readonly tag: string;
+    readonly location: Location;
+
+    readonly warnings: Array<string>;
+
+    constructor(guard: any, location: Location, options: { [ key: string ]: any }) {
+        if (guard !== Guard) { throw new Error("cannot instantiate class"); }
+
+        ethers.utils.defineReadOnly(this, "location", location);
+
+        ethers.utils.defineReadOnly(this, "tag", `node-${ nextTag++ }-${ this.constructor.name }`);
+        ethers.utils.defineReadOnly(this, "warnings", [ ]);
+
+        for (const key in options) {
+            ethers.utils.defineReadOnly(this, key, options[key]);
+        }
+    }
+
+    // Note: EVERY node must call assemble with `this`, even if only with
+    //       the bytes "0x" to trigger the offset and bytecode checks
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+        visit(this, "0x");
+        assembler.end(this);
+    }
+
+    children(): Array<Node> {
+        return [ ];
+    }
+
+    visit(visit: VisitFunc): void {
+        visit(this);
+    }
+
+    static from(options: any): Node {
+        const Factories: { [ type: string ]: { from: (options: any) => Node }} = {
+            data: DataNode,
+            decimal: LiteralNode,
+            eval: EvaluationNode,
+            exec: ExecutionNode,
+            hex: LiteralNode,
+            label: LabelNode,
+            length: LinkNode,
+            offset: LinkNode,
+            opcode: OpcodeNode,
+            scope: ScopeNode,
+        };
+
+        const factory = Factories[options.type];
+        if (!factory) { throw new Error("uknown type: " + options.type); }
+        return factory.from(options);
+    }
+}
+
+export abstract class CodeNode extends Node { }
+
+export abstract class ValueNode extends CodeNode { }
+
+
+function pushLiteral(value: ethers.utils.BytesLike | ethers.utils.Hexable | number) {
+    // Convert value into a hexstring
+    const hex = ethers.utils.hexlify(value);
+
+    if (hex === "0x") {
+        throw new Error("invalid literal: 0x");
+    }
+
+    // Make sure it will fit into a push
+    const length = ethers.utils.hexDataLength(hex);
+    if (length === 0 || length > 32) { throw new Error(`literal out of range: ${ hex }`); }
+
+    return hexConcat([ getOpcode("PUSH" + String(length)), hex ]);
+}
+
+export class LiteralNode extends ValueNode {
+    readonly value: string;
+    readonly verbatim: boolean;
+
+    constructor(guard: any, location: Location, value: string, verbatim: boolean) {
+        super(guard, location, { value, verbatim });
+    }
+
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+        if (this.verbatim) {
+            if (this.value.substring(0, 2) === "0x") {
+                visit(this, this.value);
+            } else {
+                visit(this, ethers.BigNumber.from(this.value).toHexString());
+            }
+        } else {
+            visit(this, pushLiteral(ethers.BigNumber.from(this.value)));
+        }
+        assembler.end(this);
+    }
+
+    static from(options: any): LiteralNode {
+        if (options.type !== "hex" && options.type !== "decimal") { throw new Error("expected hex or decimal type"); }
+        return new LiteralNode(Guard, options.loc, options.value, !!options.verbatim);
+    }
+}
+
+export class LinkNode extends ValueNode {
+    readonly type: string;
+    readonly label: string;
+
+    constructor(guard: any, location: Location, type: string, label: string) {
+        super(guard, location, { type, label });
+    }
+
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+
+        let value: number = null;
+
+        const target = assembler.getTarget(this.label);
+        if (target instanceof LabelNode) {
+            if (this.type === "offset") {
+                //value = assembler.getOffset(this.label);
+                value = (<number>(assembler.getLinkValue(target, this)));
+            }
+        } else {
+            const result = (<DataSource>(assembler.getLinkValue(target, this)));
+            if (this.type === "offset") {
+                //value = assembler.getOffset(this.label);
+                value = result.offset;
+            } else if (this.type === "length") {
+                //value = assembler.getLength(this.label);
+                value = result.length;
+            }
+        }
+
+        if (value == null) {
+             throw new Error("labels can only be targetted as offsets");
+        }
+
+        visit(this, pushLiteral(value));
+
+        assembler.end(this);
+    }
+
+    static from(options: any): LinkNode {
+        // @TODO: Verify type is offset or link...
+        return new LinkNode(Guard, options.loc, options.type, options.label);
+    }
+}
+
+export class OpcodeNode extends ValueNode {
+    readonly opcode: Opcode;
+    readonly operands: Array<ValueNode>;
+
+    constructor(guard: any, location: Location, opcode: Opcode, operands: Array<ValueNode>) {
+        super(guard, location, { opcode, operands });
+        if (opcode.isPush()) {
+            this.warnings.push("the PUSH opcode modifies program flow - use literals instead");
+        }
+    }
+
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+
+        // Compute the bytecode in reverse stack order
+        for (let i = this.operands.length - 1; i >= 0; i--) {
+            await this.operands[i].assemble(assembler, visit);
+        }
+
+        // Append this opcode
+        visit(this, ethers.utils.hexlify(this.opcode.value));
+
+        assembler.end(this);
+    }
+
+    children(): Array<Node> {
+        return this.operands;
+    }
+
+    visit(visit: VisitFunc): void {
+        for (let i = this.operands.length - 1; i >= 0; i--) {
+            this.operands[i].visit(visit);
+        }
+        visit(this);
+    }
+
+    static from(options: any): OpcodeNode {
+        if (options.type !== "opcode") { throw new Error("expected opcode type"); }
+        const opcode = getOpcode(options.mnemonic);
+        if (!opcode) { throw new Error("unknown opcode: " + options.mnemonic); }
+
+        // Using the function syntax will check the operand count
+        if (!options.bare) {
+            if (opcode.mnemonic === "POP" && options.operands.length === 0) {
+                // This is ok... Pop has a delta of 0, but without operands
+            } else if (options.operands.length !== opcode.delta) {
+                throw new Error(`opcode ${ opcode.mnemonic } expects ${ opcode.delta } operands`);
+            }
+        }
+
+        const operands = Object.freeze(options.operands.map((o: any) => {
+            const operand = Node.from(o);
+            if (!(operand instanceof ValueNode)) {
+                throw new Error("invalid operand");
+            }
+            return operand;
+        }));
+        return new OpcodeNode(Guard, options.loc, opcode, operands);
+    }
+}
+
+export abstract class LabelledNode extends CodeNode {
+    readonly name: string;
+
+    constructor(guard: any, location: Location, name: string, values?: { [ key: string ]: any }) {
+        values = ethers.utils.shallowCopy(values || { });
+        values.name = name;
+        super(guard, location, values);
+    }
+}
+
+export class LabelNode extends LabelledNode {
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+        visit(this, ethers.utils.hexlify(getOpcode("JUMPDEST").value));
+        assembler.end(this);
+    }
+
+    static from(options: any): LabelNode {
+        if (options.type !== "label") { throw new Error("expected label type"); }
+        return new LabelNode(Guard, options.loc, options.name);
+    }
+}
+
+export class DataNode extends LabelledNode {
+    readonly data: Array<ValueNode>;
+
+    constructor(guard: any, location: Location, name: string, data: string) {
+        super(guard, location, name, { data });
+    }
+
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+
+        for (let i = 0; i < this.data.length; i++) {
+            await this.data[i].assemble(assembler, visit);
+        }
+
+        // We pad data if is contains PUSH opcodes that would overrun
+        // the data, which could eclipse valid operations (since the
+        // VM won't execute or jump within PUSH operations)
+
+        const bytecode = ethers.utils.arrayify(assembler.getPendingBytecode(this));
+
+        // Replay the data as bytecode, skipping PUSH data
+        let i = 0;
+        while (i < bytecode.length) {
+            const opcode = getOpcode(bytecode[i++]);
+            if (opcode) {
+                i += opcode.isPush();
+            }
+        }
+
+        // The amount we overshot the data by is how much padding we need
+        const padding = new Uint8Array(i - bytecode.length);
+        // What makes more sense? INVALID or 0 (i.e. STOP)?
+        //padding.fill(getOpcode("INVALID").value);
+        padding.fill(0);
+        visit(this, ethers.utils.hexlify(padding))
+
+        assembler.end(this);
+    }
+
+    children(): Array<Node> {
+        return this.data;
+    }
+
+    visit(visit: VisitFunc): void {
+        visit(this);
+        for (let i = 0; i < this.data.length; i++) {
+            this.data[i].visit(visit);
+        }
+    }
+
+    static from(options: any): DataNode {
+        if (options.type !== "data") { throw new Error("expected data type"); }
+        return new DataNode(Guard, options.loc, options.name, Object.freeze(options.data.map((d: any) => Node.from(d))));
+    }
+}
+
+export class EvaluationNode extends ValueNode {
+    readonly script: string;
+    readonly verbatim: boolean;
+
+    constructor(guard: any, location: Location, script: string, verbatim: boolean) {
+        super(guard, location, { script, verbatim });
+    }
+
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+        const result: any = await assembler.evaluate(this.script, this);
+        if (this.verbatim) {
+            if (typeof(result) === "number") {
+                visit(this, ethers.BigNumber.from(result).toHexString());
+            } else {
+                visit(this, ethers.utils.hexlify(result));
+            }
+        } else {
+            visit(this, pushLiteral(result));
+        }
+        assembler.end(this);
+    }
+
+    static from(options: any): EvaluationNode {
+        if (options.type !== "eval") { throw new Error("expected eval type"); }
+        return new EvaluationNode(Guard, options.loc, options.script, !!options.verbatim);
+    }
+}
+
+export class ExecutionNode extends CodeNode {
+    readonly script: string;
+
+    constructor(guard: any, location: Location, script: string) {
+        super(guard, location, { script });
+    }
+
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+        await assembler.evaluate(this.script, this);
+        assembler.end(this);
+    }
+
+    static from(options: any): ExecutionNode {
+        if (options.type !== "exec") { throw new Error("expected exec type"); }
+        return new ExecutionNode(Guard, options.loc, options.script);
+    }
+}
+
+export class ScopeNode extends LabelledNode {
+    readonly statements: Array<Node>;
+
+    constructor(guard: any, location: Location, name: string, statements: Array<Node>) {
+        super(guard, location, name, { statements });
+    }
+
+    async assemble(assembler: Assembler, visit: AssembleVisitFunc): Promise<void> {
+        assembler.start(this);
+        visit(this, "0x");
+        for (let i = 0; i < this.statements.length; i++) {
+            await this.statements[i].assemble(assembler, visit);
+        }
+        assembler.end(this);
+    }
+
+    children(): Array<Node> {
+        return this.statements;
+    }
+
+    visit(visit: VisitFunc): void {
+        visit(this);
+        for (let i = 0; i < this.statements.length; i++) {
+            this.statements[i].visit(visit);
+        }
+    }
+
+    static from(options: any): ScopeNode {
+        if (options.type !== "scope") { throw new Error("expected scope type"); }
+        return new ScopeNode(Guard, options.loc, options.name, Object.freeze(options.statements.map((s: any) => Node.from(s))));
+    }
+}
+
+type _Location = {
+    first_line: number;
+    last_line: number;
+    first_column: number;
+    last_column: number;
+}
+
+export function parse(code: string): Node {
+
+    // Since jison allows \n, \r or \r\n line endings, we need some
+    // twekaing to get the correct position
+    const lines: Array<{ line: string, offset: number }> = [ ];
+    let offset = 0;
+    code.split(/(\r\n?|\n)/g).forEach((clump, index) => {
+        if (index % 2) {
+            lines[lines.length - 1].line += clump;
+        } else {
+            lines.push({ line: clump, offset: offset });
+        }
+        offset += clump.length;
+    });
+
+    // Add a mock-EOF to the end of the file so we don't out-of-bounds
+    // on the last character
+    if (lines.length) {
+        lines[lines.length - 1].line += "\n";
+    }
+
+    // Givens a line (1 offset) and column (0 offset) return the byte offset
+    const getOffset = function(line: number, column: number): number {
+        const info = lines[line - 1];
+        console.log(line, column, info);
+        if (!info || column >= info.line.length) { throw new Error("out of range"); }
+        return info.offset + column;
+    };
+
+    // We use this in the _parser to convert locations to source
+    _parser.yy._ethersLocation = function(loc?: _Location): Location {
+
+        // The _ scope should call with null to get the full source
+        if (loc == null) {
+            return Object.freeze({
+                offset: 0,
+                length: code.length,
+                source: code
+            });
+        }
+
+        const offset = getOffset(loc.first_line, loc.first_column);
+        const end = getOffset(loc.last_line, loc.last_column);
+        return Object.freeze({
+            offset: offset,
+            length: (end - offset),
+            source: code.substring(offset, end)
+        });
+    };
+
+    const result = Node.from(_parse(code));
+
+    // Nuke the source code lookup callback
+    _parser.yy._ethersLocation = null;
+
+    return result;
+}
+
+export type Operation = {
+    opcode: Opcode;
+    offset: number;
+    pushValue?: string;
+};
+
+export interface Bytecode extends Array<Operation> {
+    getOperation(offset: number): Operation;
+}
+
+export function disassemble(bytecode: string): Bytecode {
+    const ops: Array<Operation> = [ ];
+    const offsets: { [ offset: number ]: Operation } = { };
+
+    const bytes = ethers.utils.arrayify(bytecode, { allowMissingPrefix: true });
+
+    let i = 0;
+    let oob = false;
+    while (i < bytes.length) {
+        let opcode = getOpcode(bytes[i]);
+        if (!opcode) {
+            opcode = new Opcode(`unknown (${ ethers.utils.hexlify(bytes[i]) })`, bytes[i], 0, 0);
+        } else if (oob && opcode.mnemonic === "JUMPDEST") {
+            opcode = new Opcode(`JUMPDEST (invalid; OOB!!)`, bytes[i], 0, 0);
+        }
+
+        const op: Operation = {
+            opcode: opcode,
+            offset: i
+        };
+        offsets[i] = op;
+        ops.push(op);
+
+        i++;
+
+        const push = opcode.isPush();
+        if (push) {
+            const data = ethers.utils.hexlify(bytes.slice(i, i + push));
+            if (ethers.utils.hexDataLength(data) === push) {
+                op.pushValue = data;
+                i += push;
+            } else {
+                oob = true;
+            }
+        }
+    }
+
+    (<Bytecode>ops).getOperation = function(offset: number): Operation {
+        return (offsets[offset] || null);
+    };
+
+    return (<Bytecode>ops);
+}
+
+export function formatBytecode(bytecode: Array<Operation>): string {
+    const lines: Array<string> = [ ];
+
+    bytecode.forEach((op) => {
+        const opcode = op.opcode;
+
+        let offset = ethers.utils.hexZeroPad(ethers.utils.hexlify(op.offset), 2);
+        if (opcode.isValidJumpDest()) {
+            offset += "*";
+        } else {
+            offset += " ";
+        }
+
+        let operation = opcode.mnemonic;
+
+        const push = opcode.isPush();
+        if (push) {
+            if (op.pushValue) {
+                operation = op.pushValue + `${ repeat(" ", 65 - op.pushValue.length) }; ${ operation } `;
+            } else {
+                operation += `${ repeat(" ", 65 - operation.length) }; OOB!! `;
+            }
+        }
+
+        lines.push(`${ offset.substring(2) }: ${ operation }`);
+
+    });
+
+    return lines.join("\n");
+}
+
+
+interface DataSource extends Array<number> {
+    readonly offset: number;
+}
+
+type NodeState = {
+    node: Node;
+    offset: number;
+    bytecode: string;
+    pending: string;
+    object?: number | DataSource;
+};
+
+export type AssemblerOptions = {
+    filename?: string;
+    retry?: number;
+    positionIndependentCode?: boolean;
+    defines?: { [ name: string ]: any };
+};
+
+// @TODO: Rename to Assembler?
+class Assembler {
+    readonly root: Node;
+
+    readonly nodes: { [ tag: string ]: NodeState };
+    readonly labels: { [ name: string ]: LabelledNode };
+
+    readonly filename: string;
+    readonly positionIndependentCode: boolean;
+    readonly retry: number;
+
+    readonly defines: { [ name: string ]: any };
+
+    private _stack: Array<Node>;
+    private _parents: { [ tag: string ]: Node };
+    private _script: Script;
+
+    private _changed: boolean;
+
+    constructor(root: Node, options: AssemblerOptions) {
+        ethers.utils.defineReadOnly(this, "positionIndependentCode", !!options.positionIndependentCode);
+        ethers.utils.defineReadOnly(this, "retry", ((options.retry != null) ? options.retry: 512));
+        ethers.utils.defineReadOnly(this, "filename", resolve(options.filename || "./contract.asm"));
+        ethers.utils.defineReadOnly(this, "defines", Object.freeze(options.defines || { }));
+
+        ethers.utils.defineReadOnly(this, "root", root);
+
+
+        const nodes: { [ tag: string ]: NodeState } = { };
+        const labels: { [ name: string ]: Node } = { };
+        const parents: { [ tag: string ]: Node } = { };
+
+        // Link labels to their target node
+        root.visit((node) => {
+            nodes[node.tag] = {
+                node: node,
+                offset: 0x0,
+                bytecode: "0x",
+                pending: "0x"
+            };
+
+            if (node instanceof LabelledNode) {
+
+                // Check for duplicate labels
+                if (labels[node.name]) {
+                    logger.throwError(
+                        ("duplicate label: " + node.name),
+                        ethers.utils.Logger.errors.UNSUPPORTED_OPERATION,
+                        { }
+                    );
+                }
+
+                labels[node.name] = node;
+            }
+        });
+
+        root.visit((node) => {
+            // Check all labels exist
+            if (node instanceof LinkNode) {
+                const target = labels[node.label];
+                if (!target) {
+                    logger.throwError(
+                        ("missing label: " + node.label),
+                        ethers.utils.Logger.errors.UNSUPPORTED_OPERATION,
+                        { }
+                    );
+                }
+            }
+
+            // Build the parent structure
+            node.children().forEach((child) => {
+                parents[child.tag] = node;
+            });
+        });
+
+        ethers.utils.defineReadOnly(this, "labels", Object.freeze(labels));
+        ethers.utils.defineReadOnly(this, "nodes", Object.freeze(nodes));
+
+        ethers.utils.defineReadOnly(this, "_parents", Object.freeze(parents));
+
+        ethers.utils.defineReadOnly(this, "_stack", [ ]);
+
+        this.reset();
+    }
+
+    get changed(): boolean {
+        return this._changed;
+    }
+
+    // Link operations
+    getTarget(name: string): LabelledNode {
+        return this.labels[name];
+    }
+
+    // Reset the assmebler for another run with updated values
+    reset(): void {
+        this._changed = false;
+        for (const tag in this.nodes) {
+            delete this.nodes[tag].object;
+        }
+        this._script = new Script(this.filename, (name: string, context: any) => {
+            return this.get(name, context);
+        });
+    }
+
+    evaluate(script: string, source: Node): Promise<any> {
+        return this._script.evaluate(script, source);
+    }
+
+    start(node: Node): void {
+        this._stack.push(node);
+        const info = this.nodes[node.tag];
+        info.pending = "0x";
+    }
+
+    end(node: Node): void {
+        if (this._stack.pop() !== node) {
+            throw new Error("missing push/pop pair");
+        }
+
+        const info = this.nodes[node.tag];
+        if (info.pending !== info.bytecode) {
+            this._didChange();
+        }
+        info.bytecode = info.pending;
+    }
+
+    getPendingBytecode(node: Node): string {
+        return this.nodes[node.tag].pending;
+    }
+
+    _appendBytecode(bytecode: string) {
+        this._stack.forEach((node) => {
+            const info = this.nodes[node.tag];
+            info.pending = hexConcat([ info.pending, bytecode ]);
+        });
+    }
+
+    getAncestor<T = Node>(node: Node, cls: { new(...args: any[]): T }): T {
+        node = this._parents[node.tag];
+        while (node) {
+            if (node instanceof cls) { return node; }
+            node = this._parents[node.tag];
+        }
+        return null;
+    }
+
+    getLinkValue(target: LabelledNode, source: Node): number | DataSource {
+        const sourceScope: ScopeNode = ((source instanceof ScopeNode) ? source: this.getAncestor<ScopeNode>(source, ScopeNode));
+        const targetScope: ScopeNode = ((target instanceof ScopeNode) ? target: this.getAncestor<ScopeNode>(target, ScopeNode));
+
+        if (target instanceof LabelNode) {
+
+            // Label offset (e.g. "@foo:"); accessible only within its direct scope
+            //const scope = this.getAncestor(source, Scope);
+            if (targetScope !== sourceScope) {
+                throw new Error(`cannot access ${ target.name } from ${ source.tag }`);
+            }
+
+            // Return the offset relative to its scope
+            let offset = this.nodes[target.tag].offset - this.nodes[targetScope.tag].offset;
+
+            // Offsets are wrong; but we should finish this run and then try again
+            if (offset < 0) {
+                offset = 0;
+                this._didChange();
+            }
+
+            return offset;
+        }
+
+        const info = this.nodes[target.tag];
+
+        // Return the offset is relative to its scope
+        const bytes = Array.prototype.slice.call(ethers.utils.arrayify(info.bytecode));
+
+        bytes.ast = target;
+        bytes.source = target.location.source;
+
+        if (!((target instanceof DataNode) || (target instanceof ScopeNode))) {
+            throw new Error("invalid link value lookup");
+        }
+
+        // Check that target is any descendant (or self) of the source scope
+        let safeOffset = (sourceScope == targetScope);
+        if (!safeOffset) {
+            sourceScope.visit((node) => {
+                if (node === targetScope) { safeOffset = true; }
+            });
+        }
+
+        // Not safe to access the offset; this will fault if anything tries.
+        if (!safeOffset) {
+            Object.defineProperty(bytes, "offset", {
+                get: function() { throw new Error(`cannot access ${ target.name }.offset from ${ source.tag }`); }
+            });
+        }
+
+        // Add the offset relative to the scope; unless the offset has
+        // been marked as invalid, in which case accessing it will fail
+        if (safeOffset) {
+            bytes.offset = info.offset - this.nodes[sourceScope.tag].offset;
+
+            // Offsets are wqrong; but we should finish this run and then try again
+            if (bytes.offset < 0) {
+                bytes.offset = 0;
+                this._didChange();
+            }
+        }
+
+        return Object.freeze(bytes);
+    }
+
+    get(name: string, source: Node): any {
+        if (name === "defines") {
+            return this.defines;
+        }
+
+        const node = this.labels[name];
+        if (!node) { return undefined; }
+
+        const info = this.nodes[node.tag];
+        if (info.object == null) {
+            info.object = this.getLinkValue(node, source);
+        }
+        return info.object;
+    }
+
+    _didChange(): void {
+        this._changed = true;
+    }
+
+    async _assemble(): Promise<string> {
+        let offset = 0;
+        const bytecodes: Array<string> = [ ];
+        await this.root.assemble(this, (node, bytecode) => {
+            const state = this.nodes[node.tag];
+
+            // Things have moved; we will need to try again
+            if (state.offset !== offset) {
+                state.offset = offset;
+                this._didChange();
+            }
+
+            this._appendBytecode(bytecode);
+
+            bytecodes.push(bytecode);
+
+            // The bytecode has changed; we will need to try again
+            //if (state.bytecode !== bytecode) {
+            //    state.bytecode = bytecode;
+            //    this._didChange();
+            //}
+
+            offset += ethers.utils.hexDataLength(bytecode);
+        });
+        return hexConcat(bytecodes);
+    }
+
+    async assemble(): Promise<string> {
+
+        // Continue re-evaluating the bytecode until a stable set of
+        // offsets, length and values are reached.
+        let bytecode = await this._assemble();
+        for (let i = 0; i < this.retry; i++) {
+
+            // Regenerate the code with the updated assembler values
+            this.reset();
+            const adjusted = await this._assemble();
+
+            // Generated bytecode is stable!! :)
+            if (!this.changed) {
+                console.log(`Assembled in ${ i } attempts`);
+                return bytecode;
+            }
+
+            // Try again...
+            bytecode = adjusted;
+        }
+
+        // This should not happen; something is wrong with the grammar
+        // or missing enter/exit call in assemble
+        if (this._stack.length !== 0) {
+            throw new Error("bad AST");
+        }
+
+        return logger.throwError(
+            `unable to assemble; ${ this.retry } attempts failed to generate stable bytecode`,
+            ethers.utils.Logger.errors.UNKNOWN_ERROR,
+            { }
+        );
+    }
+}
+
+
+export async function assemble(ast: Node, options?: AssemblerOptions): Promise<string> {
+    const assembler = new Assembler(ast, options || { });
+    return assembler.assemble();
+}
+
+/*
+export const code = `; SimpleStore (uint)
+
+; Set the inital value of 42
+sstore(0, 42)
+
+; Init code to deploy myContract
+codecopy(0, $myContract, #myContract)
+return(0, #myContract)
+
+@myContract {
+    ; Non-payable
+    jumpi($error, callvalue)
+
+    ; Get the Sighash
+    shr({{= 256 - 32 }}, calldataload(0))
+
+    ; getValue()
+    dup1
+    {{= sighash("getValue()") }}
+    jumpi($getValue, eq)
+
+    ; setValue(uint)
+    dup1
+    {{= sighash("setValue(uint)") }}
+    jumpi($setValue, eq)
+
+    ; No matching signature
+    @error:
+        revert(0, 0)
+
+    @getValue:
+        mstore(0, sload(0))
+        return (0, 32)
+
+    @setValue:
+        ; Make sure we have exactly a uint
+        jumpi($error, iszero(eq(calldatasize, 36)))
+
+        ; Store the value
+        sstore(0, calldataload(4))
+        return (0, 0)
+
+    @checksum[
+        {{= (defines.checksum ? concat([ getOpcode("PUSH32"), id(_.source) ]): "0x") }}
+    ]
+}`;
+
+
+(async function() {
+    console.log("AST");
+    const ast = parse(code);
+    console.dir(ast, { depth: null });
+
+    const asm = await assemble(ast, { defines: { checksum: true } } );
+    console.log("ASSEMBLE\n", asm);
+
+    console.log("OPCODES\n" + formatBytecode(disassemble(asm)));
+})();
+*/
diff --git a/packages/asm/src.ts/index.ts b/packages/asm/src.ts/index.ts
new file mode 100644
index 000000000..a3eaeee66
--- /dev/null
+++ b/packages/asm/src.ts/index.ts
@@ -0,0 +1,40 @@
+"use strict";
+
+import { assemble, CodeNode, DataNode, disassemble, EvaluationNode, ExecutionNode, formatBytecode, LabelNode, LabelledNode, LinkNode, LiteralNode, Node, OpcodeNode, parse, ScopeNode, ValueNode } from "./assembler";
+import { getOpcode, Opcode } from "./opcodes";
+
+import { AssemblerOptions, AssembleVisitFunc, Bytecode, Location, Operation, VisitFunc } from "./assembler";
+
+export {
+    // Opcodes
+    getOpcode,
+    Opcode,
+
+    // Assembler functions
+    assemble,
+    disassemble,
+    formatBytecode,
+    parse,
+
+    // Assembly AST Nodes
+    CodeNode,
+    DataNode,
+    EvaluationNode,
+    ExecutionNode,
+    LabelNode,
+    LabelledNode,
+    LinkNode,
+    LiteralNode,
+    Node,
+    OpcodeNode,
+    ScopeNode,
+    ValueNode,
+
+    // Assembler Types
+    AssemblerOptions,
+    AssembleVisitFunc,
+    Bytecode,
+    Location,
+    Operation,
+    VisitFunc,
+}
diff --git a/packages/asm/src.ts/opcodes.ts b/packages/asm/src.ts/opcodes.ts
new file mode 100644
index 000000000..2c2ae5023
--- /dev/null
+++ b/packages/asm/src.ts/opcodes.ts
@@ -0,0 +1,258 @@
+"use strict";
+
+// Yellow Paper
+//   See: https://ethereum.github.io/yellowpaper/paper.pdf
+// SHL / SHR / SAR:
+//   See: https://eips.ethereum.org/EIPS/eip-145
+// CREATE2:
+//   See: https://eips.ethereum.org/EIPS/eip-1014
+// EXTCODEHASH
+//   See: https://eips.ethereum.org/EIPS/eip-1052
+
+
+import { ethers } from "ethers";
+
+export class Opcode {
+    readonly value: number;
+    readonly mnemonic: string
+
+    readonly delta: number;
+    readonly alpha: number;
+
+    readonly doc: string;
+
+    constructor(mnemonic: string, value: number, delta: number, alpha: number, doc?: string) {
+        ethers.utils.defineReadOnly(this, "mnemonic", mnemonic);
+        ethers.utils.defineReadOnly(this, "value", value);
+        ethers.utils.defineReadOnly(this, "delta", delta);
+        ethers.utils.defineReadOnly(this, "alpha", alpha);
+        ethers.utils.defineReadOnly(this, "doc", doc || null);
+    }
+
+    // Returns if this opcode is a jump
+    isJump(): boolean {
+        return (this.mnemonic === "JUMP" || this.mnemonic === "JUMPI");
+    }
+
+    isValidJumpDest(): boolean {
+        return (this.mnemonic === "JUMPDEST");
+    }
+
+    // Returns the number of of bytes this performs if a PUSH; 0 otherwise
+    isPush(): number {
+        if (this.mnemonic.substring(0, 4) === "PUSH") {
+            return this.value - 0x60 + 1;
+        }
+        return 0;
+    }
+
+    // Returns true if this operation writes to memory contents (or if readOrWrite, reads memory)
+    isMemory(readOrWrite?: boolean): boolean {
+        throw new Error("@TODO: return true if modifies memory");
+    }
+
+    // Returns true if this opcode does not affect state
+    isStatic(): boolean {
+        throw new Error("@TODO: return true if certain non-state-changing");
+    }
+}
+
+type _Opcode = {
+    value: number;
+    delta: number;
+    alpha: number;
+    doc?: string;
+};
+
+const _Opcodes: { [ name: string ]: _Opcode } = {
+    // Stop and Arithmetic Operations
+    stop:           { value: 0x00, delta: 0, alpha: 0, doc: "stop" },
+    add:            { value: 0x01, delta: 2, alpha: 1, doc: "v = add(a, b)" },
+    mul:            { value: 0x02, delta: 2, alpha: 1, doc: "v = mul(a, b)" },
+    sub:            { value: 0x03, delta: 2, alpha: 1, doc: "v = sub(a, b)" },
+    div:            { value: 0x04, delta: 2, alpha: 1, doc: "v = div(top, bottom)" },
+    sdiv:           { value: 0x05, delta: 2, alpha: 1, doc: "v = sdiv(top, bottom)" },
+    mod:            { value: 0x06, delta: 2, alpha: 1, doc: "v = mod(a, modulo)" },
+    smod:           { value: 0x07, delta: 2, alpha: 1, doc: "v = smod(a, modulo)" },
+    addmod:         { value: 0x08, delta: 3, alpha: 1, doc: "v = addmod(a, b, modulo)" },
+    mulmod:         { value: 0x09, delta: 3, alpha: 1, doc: "v = mul(a, b, modulo)" },
+    exp:            { value: 0x0a, delta: 2, alpha: 1, doc: "v = exp(base, exponent)" },
+    signextend:     { value: 0x0b, delta: 2, alpha: 1, doc: "v = signextend(value, byteWidth)" },
+
+    // Comparison & Bitwise Logic Operations
+    lt:             { value: 0x10, delta: 2, alpha: 1, doc: "v = lt(a, b)" },
+    gt:             { value: 0x11, delta: 2, alpha: 1, doc: "v = gt(a, b)" },
+    slt:            { value: 0x12, delta: 2, alpha: 1, doc: "v = slt(a, b)" },
+    sgt:            { value: 0x13, delta: 2, alpha: 1, doc: "v = sgt(a, b)" },
+    eq:             { value: 0x14, delta: 2, alpha: 1, doc: "v = eq(a, b)" },
+    iszero:         { value: 0x15, delta: 1, alpha: 1, doc: "v = iszero(a)" },
+    and:            { value: 0x16, delta: 2, alpha: 1, doc: "v = and(a, b)" },
+    or:             { value: 0x17, delta: 2, alpha: 1, doc: "v = or(a, b)" },
+    xor:            { value: 0x18, delta: 2, alpha: 1, doc: "v = xor(a, b)" },
+    not:            { value: 0x19, delta: 1, alpha: 1, doc: "v = not(a, b)" },
+    byte:           { value: 0x1a, delta: 2, alpha: 1, doc: "v = byte(msbByteIndex, value)" },
+    shl:            { value: 0x1b, delta: 2, alpha: 1, doc: "v = shl(shiftBits, value)" },
+    shr:            { value: 0x1c, delta: 2, alpha: 1, doc: "v = shr(shiftBits, value)" },
+    sar:            { value: 0x1c, delta: 2, alpha: 1, doc: "v = sar(shiftBits, value)" },
+
+    // SHA3
+    sha3:           { value: 0x20, delta: 2, alpha: 1, doc: "v = sha3(offset, length)" },
+
+    // Environmental Information
+    address:        { value: 0x30, delta: 0, alpha: 1, doc: "myAddr = address" },
+    balance:        { value: 0x31, delta: 1, alpha: 1, doc: "wei = balance(address)" },
+    origin:         { value: 0x32, delta: 0, alpha: 1, doc: "txOrigin = origin" },
+    caller:         { value: 0x33, delta: 0, alpha: 1, doc: "msgSender = caller" },
+    callvalue:      { value: 0x34, delta: 0, alpha: 1, doc: "msgValue = callvalue" },
+    calldataload:   { value: 0x35, delta: 1, alpha: 1, doc: "calldataWordValue = calldataload(byteOffet)" },
+    calldatasize:   { value: 0x36, delta: 0, alpha: 1, doc: "calldataLength = calldatasize" },
+    calldatacopy:   { value: 0x37, delta: 3, alpha: 0, doc: "calldatacopy(dstMemoryIndex, dataIndex, length)" },
+    codesize:       { value: 0x38, delta: 0, alpha: 1, doc: "myCodeLength = codesize" },
+    codecopy:       { value: 0x39, delta: 3, alpha: 0, doc: "codecopy(dstMemoryIndex, codeIndex, length)" },
+    gasprice:       { value: 0x3a, delta: 0, alpha: 1, doc: "txGasPrice = gasprice" },
+    extcodesize:    { value: 0x3b, delta: 1, alpha: 1, doc: "otherCodeLength = extcodesize(address)" },
+    extcodecopy:    { value: 0x3c, delta: 4, alpha: 0, doc: "extcodecopy(address, dstMemoryIndex, extcodeIndex, length)" },
+    returndatasize: { value: 0x3d, delta: 0, alpha: 1, doc: "v = returndatasize" },
+    returndatacopy: { value: 0x3e, delta: 3, alpha: 0, doc: "returndatacopy(dstMemoryOffset, returndataIndex, length)" },
+    extcodehash:    { value: 0x3f, delta: 1, alpha: 1, doc: "hash = extcodehash(address)" },
+
+    // Block Information
+    blockhash:      { value: 0x40, delta: 1, alpha: 1, doc: "hash = blockhash(blockNumber)" },
+    coinbase:       { value: 0x41, delta: 0, alpha: 1, doc: "miner = coinbase" },
+    timestamp:      { value: 0x42, delta: 0, alpha: 1, doc: "now = timestamp" },
+    number:         { value: 0x43, delta: 0, alpha: 1, doc: "blockNumber = number" },
+    difficulty:     { value: 0x44, delta: 0, alpha: 1, doc: "diff = difficulty" },
+    gaslimit:       { value: 0x45, delta: 0, alpha: 1, doc: "gas = gaslimit" },
+
+    // Stack, Memory, Storage and Flow Operations
+    pop:            { value: 0x50, delta: 1, alpha: 0, doc: "stackTopValue = pop" },
+    mload:          { value: 0x51, delta: 1, alpha: 1, doc: "memoryWordValue = mload(memoryByteIndex)" },
+    mstore:         { value: 0x52, delta: 2, alpha: 0, doc: "mstore(memoryByteIndex, valueOut)" },
+    mstore8:        { value: 0x53, delta: 2, alpha: 0, doc: "mstore8(memoryByteIndex, valueOut [ & 0xff ])" },
+    sload:          { value: 0x54, delta: 1, alpha: 1, doc: "storageWordValue = sload(storageWordIndex)" },
+    sstore:         { value: 0x55, delta: 2, alpha: 0, doc: "sstore(storageWordIndex, valueOut)" },
+    jump:           { value: 0x56, delta: 1, alpha: 0, doc: "jump(target)" },
+    jumpi:          { value: 0x57, delta: 2, alpha: 0, doc: "jumpi(target, notZero)" },
+    pc:             { value: 0x58, delta: 0, alpha: 1, doc: "programCounter = pc" },
+    msize:          { value: 0x59, delta: 0, alpha: 1, doc: "currentMemorySize = msize" },
+    gas:            { value: 0x5a, delta: 0, alpha: 1, doc: "remainingGas = gas" },
+    jumpdest:       { value: 0x5b, delta: 0, alpha: 0, doc: "jumpdest" },
+
+    // Push Operations
+    push1:          { value: 0x60, delta: 0, alpha: 1 },
+    push2:          { value: 0x61, delta: 0, alpha: 1 },
+    push3:          { value: 0x62, delta: 0, alpha: 1 },
+    push4:          { value: 0x63, delta: 0, alpha: 1 },
+    push5:          { value: 0x64, delta: 0, alpha: 1 },
+    push6:          { value: 0x65, delta: 0, alpha: 1 },
+    push7:          { value: 0x66, delta: 0, alpha: 1 },
+    push8:          { value: 0x67, delta: 0, alpha: 1 },
+    push9:          { value: 0x68, delta: 0, alpha: 1 },
+    push10:         { value: 0x69, delta: 0, alpha: 1 },
+    push11:         { value: 0x6a, delta: 0, alpha: 1 },
+    push12:         { value: 0x6b, delta: 0, alpha: 1 },
+    push13:         { value: 0x6c, delta: 0, alpha: 1 },
+    push14:         { value: 0x6d, delta: 0, alpha: 1 },
+    push15:         { value: 0x6e, delta: 0, alpha: 1 },
+    push16:         { value: 0x6f, delta: 0, alpha: 1 },
+    push17:         { value: 0x70, delta: 0, alpha: 1 },
+    push18:         { value: 0x71, delta: 0, alpha: 1 },
+    push19:         { value: 0x72, delta: 0, alpha: 1 },
+    push20:         { value: 0x73, delta: 0, alpha: 1 },
+    push21:         { value: 0x74, delta: 0, alpha: 1 },
+    push22:         { value: 0x75, delta: 0, alpha: 1 },
+    push23:         { value: 0x76, delta: 0, alpha: 1 },
+    push24:         { value: 0x77, delta: 0, alpha: 1 },
+    push25:         { value: 0x78, delta: 0, alpha: 1 },
+    push26:         { value: 0x79, delta: 0, alpha: 1 },
+    push27:         { value: 0x7a, delta: 0, alpha: 1 },
+    push28:         { value: 0x7b, delta: 0, alpha: 1 },
+    push29:         { value: 0x7c, delta: 0, alpha: 1 },
+    push30:         { value: 0x7d, delta: 0, alpha: 1 },
+    push31:         { value: 0x7e, delta: 0, alpha: 1 },
+    push32:         { value: 0x7f, delta: 0, alpha: 1 },
+
+    // Duplicate Operations
+    dup1:          { value: 0x80, delta: 0, alpha: 1 },
+    dup2:          { value: 0x81, delta: 0, alpha: 1 },
+    dup3:          { value: 0x82, delta: 0, alpha: 1 },
+    dup4:          { value: 0x83, delta: 0, alpha: 1 },
+    dup5:          { value: 0x84, delta: 0, alpha: 1 },
+    dup6:          { value: 0x85, delta: 0, alpha: 1 },
+    dup7:          { value: 0x86, delta: 0, alpha: 1 },
+    dup8:          { value: 0x87, delta: 0, alpha: 1 },
+    dup9:          { value: 0x88, delta: 0, alpha: 1 },
+    dup10:         { value: 0x89, delta: 0, alpha: 1 },
+    dup11:         { value: 0x8a, delta: 0, alpha: 1 },
+    dup12:         { value: 0x8b, delta: 0, alpha: 1 },
+    dup13:         { value: 0x8c, delta: 0, alpha: 1 },
+    dup14:         { value: 0x8d, delta: 0, alpha: 1 },
+    dup15:         { value: 0x8e, delta: 0, alpha: 1 },
+    dup16:         { value: 0x8f, delta: 0, alpha: 1 },
+
+    // Exchange Operations
+    swap1:         { value: 0x90, delta: 0, alpha: 0 },
+    swap2:         { value: 0x91, delta: 0, alpha: 0 },
+    swap3:         { value: 0x92, delta: 0, alpha: 0 },
+    swap4:         { value: 0x93, delta: 0, alpha: 0 },
+    swap5:         { value: 0x94, delta: 0, alpha: 0 },
+    swap6:         { value: 0x95, delta: 0, alpha: 0 },
+    swap7:         { value: 0x96, delta: 0, alpha: 0 },
+    swap8:         { value: 0x97, delta: 0, alpha: 0 },
+    swap9:         { value: 0x98, delta: 0, alpha: 0 },
+    swap10:        { value: 0x99, delta: 0, alpha: 0 },
+    swap11:        { value: 0x9a, delta: 0, alpha: 0 },
+    swap12:        { value: 0x9b, delta: 0, alpha: 0 },
+    swap13:        { value: 0x9c, delta: 0, alpha: 0 },
+    swap14:        { value: 0x9d, delta: 0, alpha: 0 },
+    swap15:        { value: 0x9e, delta: 0, alpha: 0 },
+    swap16:        { value: 0x9f, delta: 0, alpha: 0 },
+
+    // Loggin Operations
+    log0:          { value: 0xa0, delta: 2, alpha: 0 },
+    log1:          { value: 0xa1, delta: 3, alpha: 0 },
+    log2:          { value: 0xa2, delta: 4, alpha: 0 },
+    log3:          { value: 0xa3, delta: 5, alpha: 0 },
+    log4:          { value: 0xa4, delta: 6, alpha: 0 },
+
+    // System Operations
+    create:        { value: 0xf0, delta: 3, alpha: 1, doc: "address = create(value, index, length)" },
+    call:          { value: 0xf1, delta: 7, alpha: 1, doc: "v = call(gasLimit, address, value, inputIndex, inputLength, outputIndex, outputLength)" },
+    callcode:      { value: 0xf2, delta: 7, alpha: 1, doc: "v = callcode(@TODO)" },
+    "return":      { value: 0xf3, delta: 2, alpha: 0, doc: "return(index, length)" },
+    delegatecall:  { value: 0xf4, delta: 6, alpha: 1, doc: "v = delegatecall(gasLimit, address, inputIndex, inputLength, outputIndex, outputLength)" },
+    create2:       { value: 0xf5, delta: 4, alpha: 1, doc: "address = create2(value, index, length, salt)" },
+    staticcall:    { value: 0xfa, delta: 6, alpha: 1, doc: "v = staticcall(gasLimit, address, inputIndex, inputLength, outputIndex, outputLength)" },
+    revert:        { value: 0xfd, delta: 2, alpha: 0, doc: "revert(returnDataOffset, returnDataLength)" },
+    invalid:       { value: 0xfe, delta: 0, alpha: 0, doc: "invalid" },
+    suicide:       { value: 0xff, delta: 1, alpha: 0, doc: "suicide(targetAddress)" },
+};
+
+const OpcodeMap: { [ mnemonic: string ]: Opcode } = { };
+
+const Opcodes: Array<Opcode> = [ ];
+for (let i = 0; i < 256; i++) { Opcodes.push(null); }
+
+Object.keys(_Opcodes).forEach((mnemonic) => {
+    const info = _Opcodes[mnemonic];
+    const opcode = new Opcode(mnemonic.toUpperCase(), info.value, info.delta, info.alpha, info.doc);
+
+    OpcodeMap[opcode.mnemonic.toLowerCase()] = opcode;
+    Opcodes[opcode.value] = opcode;
+});
+Object.freeze(Opcodes);
+
+/*
+function repeat(char: string, length: number): string {
+    let result = char;
+    while (result.length < length) { result += result; }
+    return result.substring(0, length);
+}
+*/
+export function getOpcode(valueOrMnemonic: number | string) {
+    if (typeof(valueOrMnemonic) === "string") {
+        return OpcodeMap[valueOrMnemonic.toLowerCase()] || null;
+    }
+    return (Opcodes[valueOrMnemonic] || null);
+}
+
diff --git a/packages/asm/tsconfig.json b/packages/asm/tsconfig.json
new file mode 100644
index 000000000..324e49b1e
--- /dev/null
+++ b/packages/asm/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.package.json",
+  "compilerOptions": {
+    "rootDir": "./src.ts",
+    "outDir": "./lib/"
+  },
+  "include": [
+    "./src.ts/*"
+  ],
+  "exclude": []
+}