diff --git a/src/dapp-tests/.gitignore b/src/dapp-tests/.gitignore
new file mode 100644
index 000000000..ba6d5135e
--- /dev/null
+++ b/src/dapp-tests/.gitignore
@@ -0,0 +1,4 @@
+gethout
+hevmout
+__pycache__/
+out
diff --git a/src/dapp-tests/Makefile b/src/dapp-tests/Makefile
index edd3c150e..ad11312dc 100644
--- a/src/dapp-tests/Makefile
+++ b/src/dapp-tests/Makefile
@@ -1,5 +1,5 @@
 test:
 	pytest --hypothesis-show-statistics integration/diff-fuzz.py
-	integration/tests.sh
+	bash_unit integration/tests.sh
 
 .PHONY: test
diff --git a/src/dapp-tests/AB.sol b/src/dapp-tests/integration/contracts/AB.sol
similarity index 100%
rename from src/dapp-tests/AB.sol
rename to src/dapp-tests/integration/contracts/AB.sol
diff --git a/src/dapp-tests/dstoken.bin-runtime b/src/dapp-tests/integration/contracts/dstoken.bin-runtime
similarity index 100%
rename from src/dapp-tests/dstoken.bin-runtime
rename to src/dapp-tests/integration/contracts/dstoken.bin-runtime
diff --git a/src/dapp-tests/factor.sol b/src/dapp-tests/integration/contracts/factor.sol
similarity index 100%
rename from src/dapp-tests/factor.sol
rename to src/dapp-tests/integration/contracts/factor.sol
diff --git a/src/dapp-tests/stateful.sol b/src/dapp-tests/integration/contracts/stateful.sol
similarity index 100%
rename from src/dapp-tests/stateful.sol
rename to src/dapp-tests/integration/contracts/stateful.sol
diff --git a/src/dapp-tests/token.sol b/src/dapp-tests/integration/contracts/token.sol
similarity index 100%
rename from src/dapp-tests/token.sol
rename to src/dapp-tests/integration/contracts/token.sol
diff --git a/src/dapp-tests/integration/tests.sh b/src/dapp-tests/integration/tests.sh
index a729ea5e5..65441d63f 100755
--- a/src/dapp-tests/integration/tests.sh
+++ b/src/dapp-tests/integration/tests.sh
@@ -1,133 +1,218 @@
-#!/usr/bin/env bash
+#! /usr/bin/env bash
 
-set -ex
+set -euo pipefail
 
-# clean up
-trap 'killall geth && rm -rf "$TMPDIR"' EXIT
-trap "exit 1" SIGINT SIGTERM
+# ------------------------------------------------
+#                CONFIGURATION
+# ------------------------------------------------
 
-error() {
-    printf 1>&2 "fail: function '%s' at line %d.\n" "${FUNCNAME[1]}"  "${BASH_LINENO[0]}"
-    printf 1>&2 "got: %s" "$output"
-    exit 1
+FUZZ_RUNS=100
+TESTNET_SLEEP=5
+
+# ------------------------------------------------
+#                SHARED SETUP
+# ------------------------------------------------
+
+# we spin up a new testnet instance and share it between all tests
+setup_suite() {
+    if [[ -z "$SKIP_SETUP" ]]; then
+        TMPDIR=$(mktemp -d)
+
+        dapp testnet --dir "$TMPDIR" &
+        # give it a few secs to start up
+        sleep "$TESTNET_SLEEP"
+
+        export ETH_RPC_URL="http://127.0.0.1:8545"
+        export ETH_KEYSTORE="$TMPDIR/8545/keystore"
+        export ETH_PASSWORD=/dev/null
+        read -r ROOT _ <<< "$(seth ls --keystore "$TMPDIR/8545/keystore")"
+    fi
 }
 
-# tests some of the behaviour of
-# `dapp testnet`
-# `seth ls`
-# `seth send`
-# `seth run-tx`
-# `hevm exec`
-dapp_testnet() {
-  TMPDIR=$(mktemp -d)
+# cleanup the testnet
+teardown_suite() {
+    if [[ -z "$SKIP_SETUP" ]]; then
+        killall geth
+        rm -rf "$TMPDIR"
+    fi
+}
+
+# ------------------------------------------------
+#                TEST HELPERS
+# ------------------------------------------------
+
+# Tests for resolve-name and lookup-address use a Rinkeby name that's been registered for 100 years and will not be changed
+# Infura ID source: https://github.com/ethers-io/ethers.js/blob/0d40156fcba5be155aa5def71bcdb95b9c11d889/packages/providers/src.ts/infura-provider.ts#L17
+RINKEBY_RPC_URL=https://rinkeby.infura.io/v3/84842078b09946638c03157f83405213
+
+# generates a new account and gives it some eth, returns the address
+fresh_account() {
+    wei_amount=${1:-$(seth --to-wei 42069 ether)}
+    output=$(geth account new --password /dev/null --keystore "$ETH_KEYSTORE")
+    account=$(echo "$output" | grep "Public address of the key" | awk 'NF>1{print $NF}')
+    seth send -F "$ROOT" -V "$wei_amount" "$account" 1>&2
+    echo "$account"
+}
 
-  dapp testnet --dir "$TMPDIR" &
-  # give it a few secs to start up
-  sleep 180
-  read -r ACC BAL <<< "$(seth ls --keystore "$TMPDIR/8545/keystore")"
-  # The account has maximum balance
-  [[ $(seth --to-hex "$BAL") = $(seth --to-int256 -1) ]] || error
+# ensure that fresh_account does what it should
+test_funding() {
+    # shellcheck disable=SC2119
+    acc=$(fresh_account)
+    assert_equals "$(seth --to-wei 42069 ether)" "$(seth balance "$acc")"
 
-  # Deploy a simple contract:
-  solc --bin --bin-runtime stateful.sol -o "$TMPDIR"
+    acc=$(fresh_account "$(seth --to-wei 100 ether)")
+    assert_equals "$(seth --to-wei 100 ether)" "$(seth balance "$acc")"
+}
 
-  A_ADDR=$(seth send --create "$(<"$TMPDIR"/A.bin)" "constructor(uint y)" 1 --from "$ACC" --keystore "$TMPDIR"/8545/keystore --password /dev/null --gas 0xffffff)
+# a few useful addresses
+VITALIK=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045
+ZERO=0x0000000000000000000000000000000000000000
 
-  # Compare deployed code with what solc gives us
-  [[ $(seth code "$A_ADDR") = 0x"$(cat "$TMPDIR"/A.bin-runtime)" ]] || error
+# location of the test contracts
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+CONTRACTS="$SCRIPT_DIR/contracts"
 
-  # And with what hevm gives us
-  EXTRA_CALLDATA=$(seth --to-uint256 1)
-  HEVM_RET=$(hevm exec --code "$(<"$TMPDIR"/A.bin)""${EXTRA_CALLDATA/0x/}" --gas 0xffffff)
+# ------------------------------------------------
+#                 GENERATORS
+# ------------------------------------------------
 
-  [[ $(seth code "$A_ADDR") = "$HEVM_RET" ]] || error
+mod() {
+    bc <<< "$1%$2"
+}
 
-  TX=$(seth send "$A_ADDR" "off()" --gas 0xffff --password /dev/null --from "$ACC" --keystore "$TMPDIR"/8545/keystore --async)
+hex2dec() {
+    echo "ibase=16;${1^^}" | bc | tr -d '\\\n'
+}
 
-  # since we have one tx per block, seth run-tx and seth debug are equivalent
-  [[ $(seth run-tx "$TX") = 0x ]] || error
+byte() {
+    hexdump -n 1 -e '1/1 "%08X" 1 "\n"' /dev/urandom
+}
 
-  # dynamic fee transaction (EIP-1559)
-  seth send "$A_ADDR" "on()" --gas 0xffff --password /dev/null --from "$ACC" --keystore "$TMPDIR"/8545/keystore --prio-fee 2gwei --gas-price 10gwei
+bytes32() {
+    hexdump -n 32 -e '4/8 "%08X" 1 "\n"' /dev/urandom
+}
 
-  B_ADDR=$(seth send --create 0x647175696e6550383480393834f3 --gas 0xffff --password /dev/null --from "$ACC" --keystore "$TMPDIR"/8545/keystore --prio-fee 2gwei --gas-price 10gwei)
+uint8() {
+    hex2dec "$(byte)"
+}
 
-  [[ $(seth code "$B_ADDR") = 0x647175696e6550383480393834f3 ]] || error
+uint256() {
+    hex2dec "$(bytes32)"
+}
 
-  # clean up
-  killall geth
+alpha() {
+    local size
+    size=$1
+    tr -dc '[:alpha:]' < /dev/urandom | fold -w "${1:-$size}" | head -n 1
 }
 
-dapp_testnet
+# ------------------------------------------------
+#                   TESTS
+# ------------------------------------------------
 
-# checks that seth send works with both checksummed and unchecksummed addresses
-seth_send_address_formats() {
-  TMPDIR=$(mktemp -d)
+# tests some of the behaviour of
+# `seth send`
+# `seth run-tx`
+# `hevm exec`
+test_smoke() {
+    local account
+    account=$(fresh_account)
+
+    # Deploy a simple contract:
+    solc --bin --bin-runtime "$CONTRACTS/stateful.sol" -o "$TMPDIR"
+
+    A_ADDR=$(seth send --create "$(<"$TMPDIR"/A.bin)" "constructor(uint y)" 1 --from "$account" --keystore "$TMPDIR"/8545/keystore --password /dev/null --gas 0xffffff)
+
+    # Compare deployed code with what solc gives us
+    assert_equals 0x"$(cat "$TMPDIR"/A.bin-runtime)" "$(seth code "$A_ADDR")"
 
-  dapp testnet --dir "$TMPDIR" &
-  # give it a few secs to start up
-  sleep 180
-  read -r ACC BAL <<< "$(seth ls --keystore "$TMPDIR/8545/keystore")"
+    # And with what hevm gives us
+    EXTRA_CALLDATA=$(seth --to-uint256 1)
+    HEVM_RET=$(hevm exec --code "$(<"$TMPDIR"/A.bin)""${EXTRA_CALLDATA/0x/}" --gas 0xffffff)
 
-  lower=$(echo "$ACC" | tr '[:upper:]' '[:lower:]')
-  export ETH_GAS=0xffff
+    assert_equals "$HEVM_RET" "$(seth code "$A_ADDR")"
 
-  zero=0x0000000000000000000000000000000000000000
+    TX=$(seth send "$A_ADDR" "off()" --gas 0xffff --password /dev/null --from "$account" --keystore "$TMPDIR"/8545/keystore --async)
 
-  # with checksummed
-  tx=$(seth send "$zero" --from "$ACC" --password /dev/null --value "$(seth --to-wei 1 ether)" --keystore "$TMPDIR"/8545/keystore --async)
-  [[ $(seth tx "$tx" from) = "$lower" ]]
+    # since we have one tx per block, seth run-tx and seth debug are equivalent
+    assert_equals 0x "$(seth run-tx "$TX")"
 
-  # without checksum
-  tx=$(seth send "$zero" --from "$lower" --password /dev/null --value "$(seth --to-wei 1 ether)" --keystore "$TMPDIR"/8545/keystore --async)
-  [[ $(seth tx "$tx" from) = "$lower" ]]
+    # dynamic fee transactions (EIP-1559)
+    seth send "$A_ADDR" "on()" \
+        --gas 0xffff \
+        --password /dev/null \
+        --from "$account" \
+        --keystore "$TMPDIR"/8545/keystore \
+        --prio-fee 2gwei \
+        --gas-price 10gwei
 
-  # try again with eth_rpc_accounts
-  export ETH_RPC_ACCOUNTS=true
+    B_ADDR=$(seth send \
+        --create 0x647175696e6550383480393834f3 \
+        --gas 0xffff \
+        --password /dev/null \
+        --from "$ACC" \
+        --keystore "$TMPDIR"/8545/keystore \
+        --prio-fee 2gwei \
+        --gas-price 10gwei)
 
-  # with checksummed
-  tx=$(seth send "$zero" --from "$ACC" --password /dev/null --value "$(seth --to-wei 1 ether)" --keystore "$TMPDIR"/8545/keystore --async)
-  [[ $(seth tx "$tx" from) = "$lower" ]]
+    assert_equals 0x647175696e6550383480393834f3 "$(seth code "$B_ADDR")"
+}
+
+# checks that seth send works with both checksummed and unchecksummed addresses
+test_seth_send_address_formats() {
+    local account
+    account=$(fresh_account)
+
+    lower=$(echo "$account" | tr '[:upper:]' '[:lower:]')
+    export ETH_GAS=0xffff
 
-  # without checksum
-  tx=$(seth send "$zero" --from "$lower" --password /dev/null --value "$(seth --to-wei 1 ether)" --keystore "$TMPDIR"/8545/keystore --async)
-  [[ $(seth tx "$tx" from) = "$lower" ]]
+    # with checksummed
+    tx=$(seth send "$ZERO" --from "$ACC" --password /dev/null --value "$(seth --to-wei 1 ether)" --keystore "$TMPDIR"/8545/keystore --async)
+    assert_equals "$lower" "$(seth tx "$tx" from)"
 
-  # clean up
-  killall geth
+    # without checksum
+    tx=$(seth send "$ZERO" --from "$lower" --password /dev/null --value "$(seth --to-wei 1 ether)" --keystore "$TMPDIR"/8545/keystore --async)
+    assert_equals "$lower" "$(seth tx "$tx" from)"
+
+    # try again with eth_rpc_accounts
+    export ETH_RPC_ACCOUNTS=true
+
+    # with checksummed
+    tx=$(seth send "$ZERO" --from "$ACC" --password /dev/null --value "$(seth --to-wei 1 ether)" --keystore "$TMPDIR"/8545/keystore --async)
+    assert_equals "$lower" "$(seth tx "$tx" from)"
+
+    # without checksum
+    tx=$(seth send "$ZERO" --from "$lower" --password /dev/null --value "$(seth --to-wei 1 ether)" --keystore "$TMPDIR"/8545/keystore --async)
+    assert_equals "$lower" "$(seth tx "$tx" from)"
 }
 
-seth_send_address_formats
 
 test_hevm_symbolic() {
-    solc --bin-runtime -o . --overwrite factor.sol
+    cd "$(mktemp -d)" || exit
+
+    solc --bin-runtime -o . --overwrite "$CONTRACTS/factor.sol"
     # should find counterexample
     hevm symbolic --code "$(<A.bin-runtime)" --sig "factor(uint x, uint y)" --smttimeout 40000 --solver cvc4 && error || echo "hevm success: found counterexample"
-    rm -rf A.bin-runtime
-    hevm symbolic --code "$(<dstoken.bin-runtime)" --sig "transferFrom(address, address, uint)" --get-models
+    hevm symbolic --code "$(<"$CONTRACTS/dstoken.bin-runtime")" --sig "transferFrom(address, address, uint)" --get-models
 
-    solc --bin-runtime -o . --overwrite token.sol
+    solc --bin-runtime -o . --overwrite "$CONTRACTS/token.sol"
     # This one explores all paths (cvc4 is better at this)
     hevm symbolic --code "$(<Token.bin-runtime)" --solver cvc4
-    rm -rf Token.bin-runtime
 
     # The contracts A and B should be equivalent:
-    solc --bin-runtime -o . --overwrite AB.sol
+    solc --bin-runtime -o . --overwrite "$CONTRACTS/AB.sol"
     hevm equivalence --code-a "$(<A.bin-runtime)" --code-b "$(<B.bin-runtime)" --solver cvc4
-    rm -rf A.bin-runtime B.bin-runtime
 }
 
-test_hevm_symbolic
-
 test_custom_solc_json() {
     TMPDIR=$(mktemp -d)
 
     # copy source file
     mkdir -p "$TMPDIR/src"
-    cp factor.sol "$TMPDIR/src"
+    cp "$CONTRACTS/factor.sol" "$TMPDIR/src"
 
     # init dapp project
-    cd "$TMPDIR"
+    cd "$TMPDIR" || exit
     export GIT_CONFIG_NOSYSTEM=1
     export GIT_AUTHOR_NAME=dapp
     export GIT_AUTHOR_EMAIL=dapp@hub.lol
@@ -140,329 +225,351 @@ test_custom_solc_json() {
 
     # build with custom json
     DAPP_STANDARD_JSON="config.json" dapp build
+    assert "[[ -f out/dapp.sol.json ]]"
+}
+
+test_nonce_1() {
+    local account
+    account=$(fresh_account)
+    assert_equals 0 "$(seth nonce "$account")"
+
+    seth send -F "$account" "$VITALIK"
+    assert_equals 1 "$(seth nonce "$account")"
+}
+
+test_block_1() {
+    local account
+    account=$(fresh_account)
+
+    # block number should increase when we send a tx
+    assert_equals 1 "$(seth block-number)"
+    tx=$(seth send -F "$account" -V "$(seth --to-wei 1 ether)" "$VITALIK" --async)
+    assert_equals 2 "$(seth block-number)"
+
+    # block should contain one tx that just sent eth
+    assert_equals 21000 "$(seth block 2 gasUsed)"
+
+    # block should contain the tx that we sent before
+    txs=$(seth block 2 transactions)
+    assert_equals 1 "$(echo "$txs" | jq length)"
+    assert_equals "$tx" "$(echo "$txs" | jq -r '.[0]')"
+}
+
+test_decimal_roundtrip() {
+    for _ in $(seq $FUZZ_RUNS); do
+      local input
+      input=$(uint256)
+      assert_equals "$input" "$(seth --to-dec "$(seth --to-hex "$input")")"
+    done
+}
+
+test_hex_roundtrip() {
+    for _ in $(seq $FUZZ_RUNS); do
+      local input
+      input="0x$(bytes32)"
+      lower=$(echo "$input" | tr '[:upper:]' '[:lower:]')
+      assert_equals "$lower" "$(seth --to-hex "$(seth --to-dec "$input")")"
+    done
+}
+
+test_to_fix_roundtrip() {
+    for _ in $(seq $FUZZ_RUNS); do
+      local input digits
+      input="$(uint256)"
+      digits="$(mod "$(uint8)" 77)" # 78 decimal digits in max uint256
+      assert_equals "$input" "$(seth --from-fix "$digits" "$(seth --to-fix "$digits" "$input")")"
+    done
 }
 
-test_custom_solc_json
+test_from_fix_roundtrip() {
+    for _ in $(seq $FUZZ_RUNS); do
+      local input digits
+      input="$(uint256)"
+      length="${#input}"
+      digits="$(mod "$(uint8)" 77)" # 78 decimal digits in max uint256
+
+      [[ $digits -ge $length ]] && continue
+      whole_digits=$(bc <<< "$length - $digits" | tr -d '\\\n')
+      input="${input:0:whole_digits}.${input:$whole_digits:$length}"
+
+      assert_equals "$input" "$(seth --to-fix "$digits" "$(seth --from-fix "$digits" "$input")")"
+    done
+}
 
-# SETH CALLDATA TESTS
 test_calldata_1() {
     local output
     output=$(seth --to-uint256 1 )
-    [[ $output = "0x0000000000000000000000000000000000000000000000000000000000000001" ]] || error
+
+    assert_equals "0x0000000000000000000000000000000000000000000000000000000000000001" "$output"
 }
-test_calldata_1
 
 test_calldata_2() {
     local output
     output=$(seth calldata 'bar(bool)' false)
 
-    [[ $output = "0x6fae94120000000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0x6fae94120000000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_2
 
 test_calldata_3() {
     local output
     output=$(seth calldata 'f(bytes[])' '[0x01, 0x01]')
 
-    [[ $output = "0xd0b47c0400000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000001010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010100000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0xd0b47c0400000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000001010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010100000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_3
 
 test_calldata_4() {
     local output
     output=$(seth calldata 'f(uint a)' '1')
 
-    [[ $output = "0xb3de648b0000000000000000000000000000000000000000000000000000000000000001" ]] || error
+    assert_equals "0xb3de648b0000000000000000000000000000000000000000000000000000000000000001" "$output"
 }
-test_calldata_4
 
 test_calldata_5() {
     local output
     output=$(seth calldata 'f(uint a)' '0x01')
 
-    [[ $output = "0xb3de648b0000000000000000000000000000000000000000000000000000000000000001" ]] || error
+    assert_equals "0xb3de648b0000000000000000000000000000000000000000000000000000000000000001" "$output"
 }
-test_calldata_5
 
 test_calldata_6() {
     local output
     output=$(seth calldata 'f(bool[], uint)' '[false, true]' 1)
 
-    [[ $output = "0x7abab09100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" ]] || error
+    assert_equals "0x7abab09100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" "$output"
 }
-test_calldata_6
 
 test_calldata_7() {
     local output
     output=$(seth calldata 'f(bytes)' 0x01)
 
-    [[ $output = "0xd45754f8000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010100000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0xd45754f8000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010100000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_7
 
 test_calldata_8() {
     local output
     output=$(seth calldata 'f(bytes[])' '[0x01]')
 
-    [[ $output = "0xd0b47c0400000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010100000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0xd0b47c0400000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010100000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_8
 
 test_calldata_9() {
     local output
     output=$(seth calldata 'f(bytes[])' '[]')
 
-    [[ $output = "0xd0b47c0400000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0xd0b47c0400000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_9
 
 test_calldata_10() {
     local output
     output=$(seth calldata 'foo(bytes)' '0x')
-    [[ $output = "0x30c8d1da00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000" ]] || error
+
+    assert_equals "0x30c8d1da00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_10
 
 test_calldata_11() {
     local output
     output=$(seth calldata 'foo(bytes[])' '[0x,0x]')
 
-    [[ $output = "0x36fe9f8d000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0x36fe9f8d000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_11
 
 test_calldata_12() {
     local output
     output=$(seth calldata 'foo(bytes[])' '[0x12, 0x]')
 
-    [[ $output = "0x36fe9f8d0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000112000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0x36fe9f8d0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000112000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_12
 
 test_calldata_13() {
     local output
     output=$(seth calldata 'f(uint a)' "$(seth --to-int256 -1)")
 
-    [[ $output = "0xb3de648bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" ]] || error
+    assert_equals "0xb3de648bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" "$output"
 }
-test_calldata_13
 
 
 test_calldata_14() {
     local output
     output=$(seth calldata 'f(uint[][])' '[[1],[2,3]]')
 
-    [[ $output = "0xc26b6b9a000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003" ]] || error
+    assert_equals "0xc26b6b9a000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003" "$output"
 }
-test_calldata_14
 
 test_calldata_15() {
     local output
     output=$(seth calldata 'f(bool[][] yolo)' '[[false, true], [false]]')
 
-    [[ $output = "0x9775f34d00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0x9775f34d00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_15
 
 
 test_calldata_16() {
     local output
     output=$(seth calldata 'foo(string token)' '"hey"')
 
-    [[ $output = "0xf31a6969000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000036865790000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0xf31a6969000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000036865790000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_16
 
 test_calldata_17() {
     local output
     output=$(seth calldata 'foo(string token)' '"  hey"')
 
-    [[ $output = "0xf31a6969000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000052020686579000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0xf31a6969000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000052020686579000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_17
 
 
 test_calldata_18() {
     local output
     output=$(seth calldata 'foo(string[])' '["  hey","sad",""]')
 
-    [[ $output = "0x223f0b6000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000052020686579000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000373616400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0x223f0b6000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000052020686579000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000373616400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_calldata_18
 
 test_calldata_19() {
     local output
     output=$(seth calldata 'foo()')
 
-    [[ $output = "0xc2985578" ]] || error
+    assert_equals "0xc2985578" "$output"
 }
-test_calldata_19
 
 test_keccak_1() {
   local output
   output=$(seth keccak 0xcafe)
 
-  [[ $output = "0x72318c618151a897569554720f8f1717a3da723042fb73893c064da11b308ae9" ]] || error
+  assert_equals "0x72318c618151a897569554720f8f1717a3da723042fb73893c064da11b308ae9" "$output"
 }
-test_keccak_1
 
 test_keccak_2() {
   local output
   output=$(seth keccak 0xca:0xfe)
 
-  [[ $output = "0x72318c618151a897569554720f8f1717a3da723042fb73893c064da11b308ae9" ]] || error
+  assert_equals "0x72318c618151a897569554720f8f1717a3da723042fb73893c064da11b308ae9" "$output"
 }
-test_keccak_2
 
 test_keccak_3() {
   local output
   output=$(seth keccak cafe)
 
-  [[ $output = "0x4c84268b4bd90011342a28648371055c58267a2a8e93a7b0bc61fe93bf186974" ]] || error
+  assert_equals "0x4c84268b4bd90011342a28648371055c58267a2a8e93a7b0bc61fe93bf186974" "$output"
 }
-test_keccak_3
 
 test_hexdata_0() {
-  [[ $(seth --to-hexdata cafe) = "0xcafe" ]] || error
+  assert_equals "0xcafe" "$(seth --to-hexdata cafe)"
 }
-test_hexdata_0
 
 test_hexdata_1() {
-  [[ $(seth --to-hexdata 0xcafe) = "0xcafe" ]] || error
+  assert_equals "0xcafe" "$(seth --to-hexdata 0xcafe)"
 }
-test_hexdata_1
 
 test_hexdata_2() {
-  [[ $(seth --to-hexdata 0xCA:0xfe) = "0xcafe" ]] || error
+  assert_equals "0xcafe" "$(seth --to-hexdata 0xCA:0xfe)"
 }
-test_hexdata_2
 
 test_hexdata_3() {
-  [[ $(seth --to-hexdata 0xCA:0xfe:0x) = "0xcafe" ]] || error
+  assert_equals "0xcafe" "$(seth --to-hexdata 0xCA:0xfe:0x)"
 }
-test_hexdata_3
 
 # SETH ENS TESTS
-# Tests for resolve-name and lookup-address use a Rinkeby name that's been registered for 100 years and will not be changed
-# Infura ID source: https://github.com/ethers-io/ethers.js/blob/0d40156fcba5be155aa5def71bcdb95b9c11d889/packages/providers/src.ts/infura-provider.ts#L17
-ETH_RPC_URL=https://rinkeby.infura.io/v3/84842078b09946638c03157f83405213
 
 test_namehash_1() {
     local output
     output=$(seth namehash)
-    [[ $output = "0x0000000000000000000000000000000000000000000000000000000000000000" ]] || error
+    assert_equals "0x0000000000000000000000000000000000000000000000000000000000000000" "$output"
 }
-test_namehash_1
 
 test_namehash_2() {
     local output
     output=$(seth namehash eth)
-    [[ $output = "0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae" ]] || error
+    assert_equals "0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae" "$output"
 }
-test_namehash_2
 
 test_namehash_3() {
     local output
     output=$(seth namehash ricmoo.firefly.eth)
-    [[ $output = "0x0bcad17ecf260d6506c6b97768bdc2acfb6694445d27ffd3f9c1cfbee4a9bd6d" ]] || error
+    assert_equals "0x0bcad17ecf260d6506c6b97768bdc2acfb6694445d27ffd3f9c1cfbee4a9bd6d" "$output"
 }
-test_namehash_3
 
 test_namehash_4() {
     local output
     output=$(seth namehash seth-test.eth)
-    [[ $output = "0xc639cb4715c456d2cc8523ee5568222dbae3551e2a42c61a7da4db3ec28ab9e9" ]] || error
+    assert_equals "0xc639cb4715c456d2cc8523ee5568222dbae3551e2a42c61a7da4db3ec28ab9e9" "$output"
 }
-test_namehash_4
 
 test_namehash_5() {
-    [[ $(seth namehash eth) = $(seth namehash ETH) ]] || error
+    assert_equals "$(seth namehash ETH)" "$(seth namehash eth)"
 }
-test_namehash_5
 
 test_namehash_6() {
-    [[ $(seth namehash ricmoo.firefly.eth) = $(seth namehash RicMOO.FireFly.eTH) ]] || error
+    assert_equals "$(seth namehash ricmoo.firefly.eth)" "$(seth namehash RicMOO.FireFly.eTH)"
 }
-test_namehash_6
 
 test_namehash_7() {
-    [[ $(seth namehash seth-test.eth) = $(seth namehash sEtH-tESt.etH) ]] || error
+    assert_equals "$(seth namehash seth-test.eth)" "$(seth namehash sEtH-tESt.etH)"
 }
-test_namehash_7
 
-test-resolve-name1() {
+test_resolve_name1() {
     # using example from ethers docs: https://docs.ethers.io/v5/single-page/#/v5/api/providers/provider/-%23-Provider-ResolveName
     local output
-    output=$(seth resolve-name seth-test.eth --rpc-url=$ETH_RPC_URL)
-    [[ $output = "0x49c92F2cE8F876b070b114a6B2F8A60b83c281Ad" ]] || error
+    output=$(seth resolve-name seth-test.eth --rpc-url="$RINKEBY_RPC_URL")
+    assert_equals "0x49c92F2cE8F876b070b114a6B2F8A60b83c281Ad" "$output"
 }
-test-resolve-name1
 
-test-resolve-name2() {
-    [[ $(seth resolve-name seth-test.eth --rpc-url=$ETH_RPC_URL) = $(seth resolve-name sEtH-tESt.etH --rpc-url=$ETH_RPC_URL) ]] || error
+test_resolve_name2() {
+    assert_equals \
+      "$(seth resolve-name seth-test.eth --rpc-url=$RINKEBY_RPC_URL)" \
+      "$(seth resolve-name sEtH-tESt.etH --rpc-url=$RINKEBY_RPC_URL)"
 }
-test-resolve-name2
 
-test-lookup-address1() {
+test_lookup_address1() {
     # using example from ethers docs: https://docs.ethers.io/v5/single-page/#/v5/api/providers/provider/-%23-Provider-lookupAddress
     local output
-    output=$(seth lookup-address 0x49c92F2cE8F876b070b114a6B2F8A60b83c281Ad --rpc-url=$ETH_RPC_URL)
-    [[ $output = "seth-test.eth" ]] || error
+    output=$(seth lookup-address 0x49c92F2cE8F876b070b114a6B2F8A60b83c281Ad --rpc-url=$RINKEBY_RPC_URL)
+    assert_equals "seth-test.eth" "$output"
 }
-test-lookup-address1
 
-test-lookup-address2() {
-    [[ $(seth lookup-address 0x49c92F2cE8F876b070b114a6B2F8A60b83c281Ad --rpc-url=$ETH_RPC_URL) \
-     = $(seth lookup-address 0x49c92f2ce8f876b070b114a6b2f8a60b83c281ad --rpc-url=$ETH_RPC_URL) ]] || error
+test_lookup_address2() {
+    assert_equals \
+      "$(seth lookup-address 0x49c92F2cE8F876b070b114a6B2F8A60b83c281Ad --rpc-url=$RINKEBY_RPC_URL)" \
+      "$(seth lookup-address 0x49c92f2ce8f876b070b114a6b2f8a60b83c281ad --rpc-url=$RINKEBY_RPC_URL)"
 }
-test-lookup-address2
 
 # SETH 4BYTE TESTS
 # seth 4byte
-test-4byte() {
-    [[ $(seth 4byte a9059cbb | tail -n 1) = "transfer(address,uint256)" ]] || error
+test_4byte() {
+    assert_equals "transfer(address,uint256)" "$(seth 4byte a9059cbb | tail -n 1)"
 }
-test-4byte
 
 # SETH FIXED POINT TESTS
 # seth --from-fix
-test-from-fix1() {
-    [[ $(seth --from-fix 6 1) = 1000000 ]] || error
+test_from_fix1() {
+    assert_equals 1000000 "$(seth --from-fix 6 1)"
 }
-test-from-fix1
 
-test-from-fix2() {
-    [[ $(seth --from-fix 18 1) = 1000000000000000000 ]] || error
+test_from_fix2() {
+    assert_equals 1000000000000000000 "$(seth --from-fix 18 1)"
 }
-test-from-fix2
 
-test-from-fix3() {
-    [[ $(seth --from-fix 6 1.2345) = 1234500 ]] || error
+test_from_fix3() {
+    assert_equals 1234500 "$(seth --from-fix 6 1.2345)"
 }
-test-from-fix3
 
-test-from-fix4() {
-    [[ $(seth --from-fix 18 1.23456789) = 1234567890000000000 ]] || error
+test_from_fix4() {
+    assert_equals 1234567890000000000 "$(seth --from-fix 18 1.23456789)"
 }
-test-from-fix4
 
 # seth --to-fix
-test-to-fix1() {
-    [[ $(seth --to-fix 6 1000000) = 1.000000 ]] || error
+test_to_fix1() {
+    assert_equals 1.000000 "$(seth --to-fix 6 1000000)"
 }
-test-to-fix1
 
-test-to-fix2() {
-    [[ $(seth --to-fix 18 1000000000000000000) = 1.000000000000000000 ]] || error
+test_to_fix2() {
+    assert_equals 1.000000000000000000 "$(seth --to-fix 18 1000000000000000000)"
 }
-test-to-fix2
 
-test-to-fix3() {
-    [[ $(seth --to-fix 6 1234500) = 1.234500 ]] || error
+test_to_fix3() {
+    assert_equals 1.234500 "$(seth --to-fix 6 1234500)"
 }
-test-to-fix3
 
-test-to-fix4() {
-    [[ $(seth --to-fix 18 1234567890000000000) = 1.234567890000000000 ]] || error
+test_to_fix4() {
+    assert_equals 1.234567890000000000 "$(seth --to-fix 18 1234567890000000000)"
 }
-test-to-fix4
\ No newline at end of file
diff --git a/src/dapp-tests/shell.nix b/src/dapp-tests/shell.nix
index 95097236a..dee3268db 100644
--- a/src/dapp-tests/shell.nix
+++ b/src/dapp-tests/shell.nix
@@ -8,11 +8,11 @@ let
     hypothesis
     pytest
     # other python packages you want
-  ]; 
+  ];
   python-with-pkgs = python3.withPackages my-python-packages;
 in
 
 mkShell {
   name = "dapp-tests";
-  buildInputs = [ killall cacert bashInteractive curl dapp gnumake hevm procps seth solc go-ethereum python-with-pkgs ];
+  buildInputs = [ killall bash_unit cacert bashInteractive curl dapp gnumake hevm procps seth solc go-ethereum python-with-pkgs ];
 }
diff --git a/src/seth/libexec/seth/seth---from-fix b/src/seth/libexec/seth/seth---from-fix
index dcbf26dd3..9ed8b4b87 100755
--- a/src/seth/libexec/seth/seth---from-fix
+++ b/src/seth/libexec/seth/seth---from-fix
@@ -7,4 +7,4 @@ set -e
 decimals=$1
 number=$2
 
-bc <<<"$number * 10 ^ $decimals / 1" # dividing by 1 ensures integer output
+bc <<<"$number * 10 ^ $decimals / 1" | tr -d '\\\n' # dividing by 1 ensures integer output