diff --git a/middleware/packet-forward-middleware/e2e/packet_forward_test.go b/middleware/packet-forward-middleware/e2e/packet_forward_test.go
index 7f47d003..5522a708 100644
--- a/middleware/packet-forward-middleware/e2e/packet_forward_test.go
+++ b/middleware/packet-forward-middleware/e2e/packet_forward_test.go
@@ -178,155 +178,153 @@ func TestPacketForwardMiddleware(t *testing.T) {
 	zeroBal := math.ZeroInt()
 	transferAmount := math.NewInt(100_000)
 
-	/*
-		t.Run("multi-hop a->b->c->d", func(t *testing.T) {
-			// Send packet from Chain A->Chain B->Chain C->Chain D
-			transfer := ibc.WalletAmount{
-				Address: userB.FormattedAddress(),
-				Denom:   chainA.Config().Denom,
-				Amount:  transferAmount,
-			}
+	t.Run("multi-hop a->b->c->d", func(t *testing.T) {
+		// Send packet from Chain A->Chain B->Chain C->Chain D
+		transfer := ibc.WalletAmount{
+			Address: userB.FormattedAddress(),
+			Denom:   chainA.Config().Denom,
+			Amount:  transferAmount,
+		}
 
-			secondHopMetadata := &PacketMetadata{
-				Forward: &ForwardMetadata{
-					Receiver: userD.FormattedAddress(),
-					Channel:  cdChan.ChannelID,
-					Port:     cdChan.PortID,
-				},
-			}
-			nextBz, err := json.Marshal(secondHopMetadata)
-			require.NoError(t, err)
-			next := string(nextBz)
-
-			firstHopMetadata := &PacketMetadata{
-				Forward: &ForwardMetadata{
-					Receiver: userC.FormattedAddress(),
-					Channel:  bcChan.ChannelID,
-					Port:     bcChan.PortID,
-					Next:     &next,
-				},
-			}
+		secondHopMetadata := &PacketMetadata{
+			Forward: &ForwardMetadata{
+				Receiver: userD.FormattedAddress(),
+				Channel:  cdChan.ChannelID,
+				Port:     cdChan.PortID,
+			},
+		}
+		nextBz, err := json.Marshal(secondHopMetadata)
+		require.NoError(t, err)
+		next := string(nextBz)
 
-			memo, err := json.Marshal(firstHopMetadata)
-			require.NoError(t, err)
+		firstHopMetadata := &PacketMetadata{
+			Forward: &ForwardMetadata{
+				Receiver: userC.FormattedAddress(),
+				Channel:  bcChan.ChannelID,
+				Port:     bcChan.PortID,
+				Next:     &next,
+			},
+		}
 
-			chainAHeight, err := chainA.Height(ctx)
-			require.NoError(t, err)
+		memo, err := json.Marshal(firstHopMetadata)
+		require.NoError(t, err)
 
-			transferTx, err := chainA.SendIBCTransfer(ctx, abChan.ChannelID, userA.KeyName(), transfer, ibc.TransferOptions{Memo: string(memo)})
-			require.NoError(t, err)
-			_, err = testutil.PollForAck(ctx, chainA, chainAHeight, chainAHeight+30, transferTx.Packet)
-			require.NoError(t, err)
-			err = testutil.WaitForBlocks(ctx, waitBlocks, chainA)
-			require.NoError(t, err)
+		chainAHeight, err := chainA.Height(ctx)
+		require.NoError(t, err)
 
-			chainABalance, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom)
-			require.NoError(t, err)
+		transferTx, err := chainA.SendIBCTransfer(ctx, abChan.ChannelID, userA.KeyName(), transfer, ibc.TransferOptions{Memo: string(memo)})
+		require.NoError(t, err)
+		_, err = testutil.PollForAck(ctx, chainA, chainAHeight, chainAHeight+30, transferTx.Packet)
+		require.NoError(t, err)
+		err = testutil.WaitForBlocks(ctx, waitBlocks, chainA)
+		require.NoError(t, err)
 
-			chainBBalance, err := chainB.GetBalance(ctx, userB.FormattedAddress(), firstHopIBCDenom)
-			require.NoError(t, err)
+		chainABalance, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom)
+		require.NoError(t, err)
 
-			chainCBalance, err := chainC.GetBalance(ctx, userC.FormattedAddress(), secondHopIBCDenom)
-			require.NoError(t, err)
+		chainBBalance, err := chainB.GetBalance(ctx, userB.FormattedAddress(), firstHopIBCDenom)
+		require.NoError(t, err)
 
-			chainDBalance, err := chainD.GetBalance(ctx, userD.FormattedAddress(), thirdHopIBCDenom)
-			require.NoError(t, err)
+		chainCBalance, err := chainC.GetBalance(ctx, userC.FormattedAddress(), secondHopIBCDenom)
+		require.NoError(t, err)
 
-			require.True(t, chainABalance.Equal(initBal.Sub(transferAmount)))
-			require.True(t, chainBBalance.Equal(zeroBal))
-			require.True(t, chainCBalance.Equal(zeroBal))
-			require.True(t, chainDBalance.Equal(transferAmount))
+		chainDBalance, err := chainD.GetBalance(ctx, userD.FormattedAddress(), thirdHopIBCDenom)
+		require.NoError(t, err)
 
-			firstHopEscrowBalance, err := chainA.GetBalance(ctx, firstHopEscrowAccount, chainA.Config().Denom)
-			require.NoError(t, err)
+		require.True(t, chainABalance.Equal(initBal.Sub(transferAmount)))
+		require.True(t, chainBBalance.Equal(zeroBal))
+		require.True(t, chainCBalance.Equal(zeroBal))
+		require.True(t, chainDBalance.Equal(transferAmount))
 
-			secondHopEscrowBalance, err := chainB.GetBalance(ctx, secondHopEscrowAccount, firstHopIBCDenom)
-			require.NoError(t, err)
+		firstHopEscrowBalance, err := chainA.GetBalance(ctx, firstHopEscrowAccount, chainA.Config().Denom)
+		require.NoError(t, err)
 
-			thirdHopEscrowBalance, err := chainC.GetBalance(ctx, thirdHopEscrowAccount, secondHopIBCDenom)
-			require.NoError(t, err)
+		secondHopEscrowBalance, err := chainB.GetBalance(ctx, secondHopEscrowAccount, firstHopIBCDenom)
+		require.NoError(t, err)
 
-			require.Equal(t, transferAmount, firstHopEscrowBalance)
-			require.Equal(t, transferAmount, secondHopEscrowBalance)
-			require.Equal(t, transferAmount, thirdHopEscrowBalance)
-		})
+		thirdHopEscrowBalance, err := chainC.GetBalance(ctx, thirdHopEscrowAccount, secondHopIBCDenom)
+		require.NoError(t, err)
 
-		t.Run("multi-hop denom unwind d->c->b->a", func(t *testing.T) {
-			// Send packet back from Chain D->Chain C->Chain B->Chain A
-			transfer := ibc.WalletAmount{
-				Address: userC.FormattedAddress(),
-				Denom:   thirdHopIBCDenom,
-				Amount:  transferAmount,
-			}
+		require.Equal(t, transferAmount, firstHopEscrowBalance)
+		require.Equal(t, transferAmount, secondHopEscrowBalance)
+		require.Equal(t, transferAmount, thirdHopEscrowBalance)
+	})
 
-			secondHopMetadata := &PacketMetadata{
-				Forward: &ForwardMetadata{
-					Receiver: userA.FormattedAddress(),
-					Channel:  baChan.ChannelID,
-					Port:     baChan.PortID,
-				},
-			}
+	t.Run("multi-hop denom unwind d->c->b->a", func(t *testing.T) {
+		// Send packet back from Chain D->Chain C->Chain B->Chain A
+		transfer := ibc.WalletAmount{
+			Address: userC.FormattedAddress(),
+			Denom:   thirdHopIBCDenom,
+			Amount:  transferAmount,
+		}
 
-			nextBz, err := json.Marshal(secondHopMetadata)
-			require.NoError(t, err)
+		secondHopMetadata := &PacketMetadata{
+			Forward: &ForwardMetadata{
+				Receiver: userA.FormattedAddress(),
+				Channel:  baChan.ChannelID,
+				Port:     baChan.PortID,
+			},
+		}
 
-			next := string(nextBz)
+		nextBz, err := json.Marshal(secondHopMetadata)
+		require.NoError(t, err)
 
-			firstHopMetadata := &PacketMetadata{
-				Forward: &ForwardMetadata{
-					Receiver: userB.FormattedAddress(),
-					Channel:  cbChan.ChannelID,
-					Port:     cbChan.PortID,
-					Next:     &next,
-				},
-			}
+		next := string(nextBz)
 
-			memo, err := json.Marshal(firstHopMetadata)
-			require.NoError(t, err)
+		firstHopMetadata := &PacketMetadata{
+			Forward: &ForwardMetadata{
+				Receiver: userB.FormattedAddress(),
+				Channel:  cbChan.ChannelID,
+				Port:     cbChan.PortID,
+				Next:     &next,
+			},
+		}
 
-			chainDHeight, err := chainD.Height(ctx)
-			require.NoError(t, err)
+		memo, err := json.Marshal(firstHopMetadata)
+		require.NoError(t, err)
 
-			transferTx, err := chainD.SendIBCTransfer(ctx, dcChan.ChannelID, userD.KeyName(), transfer, ibc.TransferOptions{Memo: string(memo)})
-			require.NoError(t, err)
-			_, err = testutil.PollForAck(ctx, chainD, chainDHeight, chainDHeight+30, transferTx.Packet)
-			require.NoError(t, err)
-			err = testutil.WaitForBlocks(ctx, waitBlocks, chainA)
-			require.NoError(t, err)
+		chainDHeight, err := chainD.Height(ctx)
+		require.NoError(t, err)
 
-			// assert balances for user controlled wallets
-			chainDBalance, err := chainD.GetBalance(ctx, userD.FormattedAddress(), thirdHopIBCDenom)
-			require.NoError(t, err)
+		transferTx, err := chainD.SendIBCTransfer(ctx, dcChan.ChannelID, userD.KeyName(), transfer, ibc.TransferOptions{Memo: string(memo)})
+		require.NoError(t, err)
+		_, err = testutil.PollForAck(ctx, chainD, chainDHeight, chainDHeight+30, transferTx.Packet)
+		require.NoError(t, err)
+		err = testutil.WaitForBlocks(ctx, waitBlocks, chainA)
+		require.NoError(t, err)
 
-			chainCBalance, err := chainC.GetBalance(ctx, userC.FormattedAddress(), secondHopIBCDenom)
-			require.NoError(t, err)
+		// assert balances for user controlled wallets
+		chainDBalance, err := chainD.GetBalance(ctx, userD.FormattedAddress(), thirdHopIBCDenom)
+		require.NoError(t, err)
 
-			chainBBalance, err := chainB.GetBalance(ctx, userB.FormattedAddress(), firstHopIBCDenom)
-			require.NoError(t, err)
+		chainCBalance, err := chainC.GetBalance(ctx, userC.FormattedAddress(), secondHopIBCDenom)
+		require.NoError(t, err)
 
-			chainABalance, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom)
-			require.NoError(t, err)
+		chainBBalance, err := chainB.GetBalance(ctx, userB.FormattedAddress(), firstHopIBCDenom)
+		require.NoError(t, err)
 
-			require.True(t, chainDBalance.Equal(zeroBal))
-			require.True(t, chainCBalance.Equal(zeroBal))
-			require.True(t, chainBBalance.Equal(zeroBal))
-			require.True(t, chainABalance.Equal(initBal))
+		chainABalance, err := chainA.GetBalance(ctx, userA.FormattedAddress(), chainA.Config().Denom)
+		require.NoError(t, err)
+
+		require.True(t, chainDBalance.Equal(zeroBal))
+		require.True(t, chainCBalance.Equal(zeroBal))
+		require.True(t, chainBBalance.Equal(zeroBal))
+		require.True(t, chainABalance.Equal(initBal))
 
-			// assert balances for IBC escrow accounts
-			firstHopEscrowBalance, err := chainA.GetBalance(ctx, firstHopEscrowAccount, chainA.Config().Denom)
-			require.NoError(t, err)
+		// assert balances for IBC escrow accounts
+		firstHopEscrowBalance, err := chainA.GetBalance(ctx, firstHopEscrowAccount, chainA.Config().Denom)
+		require.NoError(t, err)
 
-			secondHopEscrowBalance, err := chainB.GetBalance(ctx, secondHopEscrowAccount, firstHopIBCDenom)
-			require.NoError(t, err)
+		secondHopEscrowBalance, err := chainB.GetBalance(ctx, secondHopEscrowAccount, firstHopIBCDenom)
+		require.NoError(t, err)
 
-			thirdHopEscrowBalance, err := chainC.GetBalance(ctx, thirdHopEscrowAccount, secondHopIBCDenom)
-			require.NoError(t, err)
+		thirdHopEscrowBalance, err := chainC.GetBalance(ctx, thirdHopEscrowAccount, secondHopIBCDenom)
+		require.NoError(t, err)
 
-			require.True(t, firstHopEscrowBalance.Equal(zeroBal))
-			require.True(t, secondHopEscrowBalance.Equal(zeroBal))
-			require.True(t, thirdHopEscrowBalance.Equal(zeroBal))
-		})
-	*/
+		require.True(t, firstHopEscrowBalance.Equal(zeroBal))
+		require.True(t, secondHopEscrowBalance.Equal(zeroBal))
+		require.True(t, thirdHopEscrowBalance.Equal(zeroBal))
+	})
 
 	t.Run("forward ack error refund", func(t *testing.T) {
 		// Send a malformed packet with invalid receiver address from Chain A->Chain B->Chain C
diff --git a/middleware/packet-forward-middleware/test_node.sh b/middleware/packet-forward-middleware/test_node.sh
deleted file mode 100644
index 0939b823..00000000
--- a/middleware/packet-forward-middleware/test_node.sh
+++ /dev/null
@@ -1,119 +0,0 @@
-#!/bin/bash
-# Run this script to quickly install, setup, and run the current version of simd without docker.
-#
-# Example:
-# CHAIN_ID="local-1" HOME_DIR="$HOME/.simapp" TIMEOUT_COMMIT="500ms" CLEAN=true sh test_node.sh
-# CHAIN_ID="local-2" HOME_DIR="~/.sim2" CLEAN=true RPC=36657 REST=2317 PROFF=6061 P2P=36656 GRPC=8090 GRPC_WEB=8091 ROSETTA=8081 TIMEOUT_COMMIT="500ms" sh scripts/test_node.sh
-#
-# To use unoptomized wasm files up to ~5mb, add: MAX_WASM_SIZE=5000000
-
-export KEY="cosmos1"
-export KEY2="cosmos2"
-
-export CHAIN_ID=${CHAIN_ID:-"local-1"}
-export MONIKER="local"
-export KEYALGO="secp256k1"
-export KEYRING=${KEYRING:-"os"}
-export HOME_DIR=$(eval echo "${HOME_DIR:-"$HOME/.simapp"}")
-export BINARY=${BINARY:-simd}
-
-export CLEAN=${CLEAN:-"false"}
-export RPC=${RPC:-"26657"}
-export REST=${REST:-"1317"}
-export PROFF=${PROFF:-"6060"}
-export P2P=${P2P:-"26656"}
-export GRPC=${GRPC:-"9090"}
-export GRPC_WEB=${GRPC_WEB:-"9091"}
-export ROSETTA=${ROSETTA:-"8080"}
-export TIMEOUT_COMMIT=${TIMEOUT_COMMIT:-"5s"}
-
-alias BINARY="$BINARY --home=$HOME_DIR"
-
-command -v $BINARY > /dev/null 2>&1 || { echo >&2 "$BINARY command not found. Ensure this is setup / properly installed in your GOPATH (make install)."; exit 1; }
-command -v jq > /dev/null 2>&1 || { echo >&2 "jq not installed. More info: https://stedolan.github.io/jq/download/"; exit 1; }
-
-$BINARY config keyring-backend $KEYRING
-$BINARY config chain-id $CHAIN_ID
-
-from_scratch () {
-  # Fresh install on current branch
-  make install
-
-  # remove existing daemon.
-  rm -rf $HOME_DIR && echo "Removed $HOME_DIR"
-  
-  # sim1efd63aw40lxf3n4mhf7dzhjkr453axurv2zdzk
-  echo "decorate bright ozone fork gallery riot bus exhaust worth way bone indoor calm squirrel merry zero scheme cotton until shop any excess stage laundry" | BINARY keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO --recover
-  # sim1hj5fveer5cjtn4wd6wstzugjfdxzl0xps73ftl
-  echo "wealth flavor believe regret funny network recall kiss grape useless pepper cram hint member few certain unveil rather brick bargain curious require crowd raise" | BINARY keys add $KEY2 --keyring-backend $KEYRING --algo $KEYALGO --recover
-  
-  BINARY init $MONIKER --chain-id $CHAIN_ID --default-denom token --home=$HOME_DIR
-
-  # Function updates the config based on a jq argument as a string
-  update_test_genesis () {    
-    cat $HOME_DIR/config/genesis.json | jq "$1" > $HOME_DIR/config/tmp_genesis.json && mv $HOME_DIR/config/tmp_genesis.json $HOME_DIR/config/genesis.json
-  }
-
-  # Block
-  update_test_genesis '.consensus_params["block"]["max_gas"]="100000000"'
-  # Gov
-  update_test_genesis '.app_state["gov"]["params"]["min_deposit"]=[{"denom": "token","amount": "1000000"}]'
-  update_test_genesis '.app_state["gov"]["voting_params"]["voting_period"]="15s"'
-  # staking
-  update_test_genesis '.app_state["staking"]["params"]["bond_denom"]="token"'  
-  update_test_genesis '.app_state["staking"]["params"]["min_commission_rate"]="0.050000000000000000"'  
-  # mint
-  update_test_genesis '.app_state["mint"]["params"]["mint_denom"]="token"'  
-  # crisis
-  update_test_genesis '.app_state["crisis"]["constant_fee"]={"denom": "token","amount": "1000"}' 
-
-  # PFM
-  update_test_genesis '.app_state["packetfowardmiddleware"]["params"]["fee_percentage"]="0.000000000000000000"'
-
-  # Allocate genesis accounts
-  BINARY genesis add-genesis-account $KEY 10000000token,1000utest --keyring-backend $KEYRING --home=$HOME_DIR
-  BINARY genesis add-genesis-account $KEY2 1000000token,1000utest --keyring-backend $KEYRING  
-
-  BINARY genesis gentx $KEY 1000000token --keyring-backend $KEYRING --chain-id $CHAIN_ID
-
-  # Collect genesis tx
-  BINARY genesis collect-gentxs
-
-  # Run this to ensure everything worked and that the genesis file is setup correctly
-  BINARY genesis validate-genesis
-}
-
-# check if CLEAN is not set to false
-if [ "$CLEAN" != "false" ]; then
-  echo "Starting from a clean state"
-  from_scratch
-fi
-
-echo "Starting node..."
-
-# Opens the RPC endpoint to outside connections
-sed -i 's/laddr = "tcp:\/\/127.0.0.1:26657"/c\laddr = "tcp:\/\/0.0.0.0:'$RPC'"/g' $HOME_DIR/config/config.toml
-sed -i 's/cors_allowed_origins = \[\]/cors_allowed_origins = \["\*"\]/g' $HOME_DIR/config/config.toml
-
-# REST endpoint
-sed -i 's/address = "tcp:\/\/localhost:1317"/address = "tcp:\/\/0.0.0.0:'$REST'"/g' $HOME_DIR/config/app.toml
-sed -i 's/enable = false/enable = true/g' $HOME_DIR/config/app.toml
-
-# replace pprof_laddr = "localhost:6060" binding
-sed -i 's/pprof_laddr = "localhost:6060"/pprof_laddr = "localhost:'$PROFF_LADDER'"/g' $HOME_DIR/config/config.toml
-
-# change p2p addr laddr = "tcp://0.0.0.0:26656"
-sed -i 's/laddr = "tcp:\/\/0.0.0.0:26656"/laddr = "tcp:\/\/0.0.0.0:'$P2P'"/g' $HOME_DIR/config/config.toml
-
-# GRPC
-sed -i 's/address = "localhost:9090"/address = "0.0.0.0:'$GRPC'"/g' $HOME_DIR/config/app.toml
-sed -i 's/address = "localhost:9091"/address = "0.0.0.0:'$GRPC_WEB'"/g' $HOME_DIR/config/app.toml
-
-# Rosetta Api
-sed -i 's/address = ":8080"/address = "0.0.0.0:'$ROSETTA'"/g' $HOME_DIR/config/app.toml
-
-# faster blocks
-sed -i 's/timeout_commit = "5s"/timeout_commit = "'$TIMEOUT_COMMIT'"/g' $HOME_DIR/config/config.toml
-
-# Start the node with 0 gas fees
-BINARY start --pruning=nothing  --minimum-gas-prices=0token --rpc.laddr="tcp://0.0.0.0:$RPC"
\ No newline at end of file
diff --git a/middleware/packet-forward-middleware/testing/new_simapp.zip b/middleware/packet-forward-middleware/testing/new_simapp.zip
deleted file mode 100644
index 48d954f7..00000000
Binary files a/middleware/packet-forward-middleware/testing/new_simapp.zip and /dev/null differ
diff --git a/middleware/packet-forward-middleware/testing/old_simapp.zip b/middleware/packet-forward-middleware/testing/old_simapp.zip
deleted file mode 100644
index 5382ecbc..00000000
Binary files a/middleware/packet-forward-middleware/testing/old_simapp.zip and /dev/null differ