Wondering what’s next for npm?Check out our public roadmap! »

    TypeScript icon, indicating that this package has built-in type declarations

    5.0.6 • Public • Published

    ASM Utilities

    Experimental Do not use this package in production (yet)

    A semi-advanced EVM assembler.


    • 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 ]



    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


    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.



    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.


    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)


    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 {

    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() }}


    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 {
           {{= junk }}

    Or code that tries to include its own hash internally:

    @myContract {
       ; NOT OK! hash(hash(hash( .... (data))) will never resolve stable bytecode
           {{= keccak256(myContract) }}
       ; The hash excluding of bytecode excluding the checksum works.
           {{= keccak256(myContract.slice(0, checksumOk.offset)) }}
           {{= zeroPad("0x", 32) }}
           {{= keccak256(myContract.slice(checksumOk.offset + 32)) }}
       ; But this is fine... The source code of a file does not change
          {{= id(myContract.source) }
       ; Even better; this will make disassembled code look nicer...
          {{= concat([ Opcode.from("PUSH32"), id(myContract.source) ]) }


    If you make changes to the grammar.jison file, make sure to run the npm generate command to re-build the AST parser.


    MIT License.


    npm i @wansproject/asm

    DownloadsWeekly Downloads






    Unpacked Size

    295 kB

    Total Files


    Last publish


    • avatar
    • avatar