diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 000000000..6ada5fe8e
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,10 @@
+docker/devnet/data
+react/node_modules
+# filecoin-ffi installation
+build/.filecoin-install
+extern/filecoin-ffi/.install-filcrypto
+extern/filecoin-ffi/filcrypto.*
+extern/filecoin-ffi/libfilcrypto.a
+# local binaries
+boost*
+devnet
diff --git a/README.md b/README.md
index 06e6460a3..1897ecd14 100644
--- a/README.md
+++ b/README.md
@@ -4,79 +4,290 @@ Boost is a tool for Filecoin storage providers to manage data storage and retrie
 
 See the docs at [https://boost.filecoin.io](https://boost.filecoin.io/getting-started) to get started.
 
-## For development:
+## Table of Contents
 
+- [Building and Installing Boost](#building-and-installing-boost)
+- [Running Boost for development](#running-boost-for-development)
+- [Running Boost devnet in Docker](#running-boost-devnet-in-docker)
+- [License](#license)
 
-1. Install using instructions in the building and installation section in [the docs](https://boost.filecoin.io/getting-started#building-and-installing).
+## Building and Installing Boost
 
-2. Make sure you have a local Lotus fullnode and miner running and listening to `localhost:1234` and `localhost:2345` respectively, for example with a devnet:
+Compile and install using the instructions at the `Building and installing` section in [the docs](https://boost.filecoin.io/getting-started#building-and-installing).
 
+## Running Boost for development
+
+To run Boost on your development machine, you will need to set up a devnet:
+
+1. Remove any existing Lotus and Boost repositories
 ```
-devnet
+rm -rf ~/.lotusmarkets ~/.lotus ~/.lotusminer ~/.genesis_sectors
+rm -rf ~/.boost
 ```
 
-Note that currently `devnet` is using the default paths that `lotus` and `lotus-miner` use for their repositories, and you should make sure these directories are empty:
+2. Build Lotus in debug mode
 
+The version of lotus needs to match the version in Boost's go.mod
 ```
-LOTUS_PATH=~/.lotus
-LOTUS_MINER_PATH=~/.lotusminer
+cd lotus
+git checkout <tag>
+make debug
+```
+
+3. Install Lotus
 
-rm -rf ~/.lotus ~/.lotusminer
+The devnet script uses the installed `lotus` and `lotus-miner` binaries to run the miner and daemon.
+```
+make install
+install -C ./lotus-seed /usr/local/bin/lotus-seed
 ```
 
+4. Build Boost in debug mode
 
-3. Create Boost repository
+Double check if environment variables are set:
+```
+export LIBRARY_PATH=/opt/homebrew/lib
+export PATH="$(brew --prefix coreutils)/libexec/gnubin:/usr/local/bin:$PATH"
+```
 
+Build and install
 ```
-export $(lotus auth api-info --perm=admin)
-export $(lotus-miner auth api-info --perm=admin)
+cd boost
+make debug
+make install
+```
+
+5. Start the devnet
 
-boostd --vv init \
-       --api-sealer=`lotus-miner auth api-info --perm=admin` \
-       --api-sector-index=`lotus-miner auth api-info --perm=admin` \
-       --wallet-publish-storage-deals=`lotus wallet new bls` \
-       --wallet-deal-collateral=`lotus wallet new bls` \
-       --max-staging-deals-bytes=50000000000
+The following command will use the binaries that you built and installed above, and will run `lotus`, `lotus-miner` and `lotus-seed`. The `lotus` version must match the version in Boost's go.mod.
+```
+cd boost
+./devnet
 ```
 
-4. Run the Boost daemon service
+The first time you run it, it will download the Filecoin proof parameters. It will take at least 10 minutes depending on your connection speed. You may need to restart the command multiple times as your terminal will probably timeout before it finishes downloading everything.
 
+The devnet isn't designed to be restartable. After it has been successfully run once, you'll have to clear out the previous data before re-running `./devnet`:
+```
+rm -rf ~/.lotusmarkets && rm -rf ~/.lotus && rm -rf ~/.lotusminer && rm -rf ~/.genesis_sectors
 ```
-export $(lotus auth api-info --perm=admin)
 
-boostd --vv run
+6. Wait for `lotus-miner` to come up (through the command above)
+
+Unset these variables as they interfere with the `lotus-miner` command.
+```
+unset MINER_API_INFO
+unset FULLNODE_API_INFO
 ```
 
-5. Interact with Boost
+Then repeatedly run this command until it succeeds:
+```
+lotus-miner auth api-info --perm=admin
+```
 
-Pass the client address (wallet) and the provider address to the `dummydeal` command.
-Note that
-- the client address is the address of a wallet with funds in `lotus wallet list`
-- you can find the provider address in `~/.boost/config.toml` under the config key `Wallets.Miner`
+7. Get the authentication tokens to connect to the lotus daemon and miner:
 
 ```
-boostd dummydeal <client address> <provider address>
+export ENV_MINER_API_INFO=`lotus-miner auth api-info --perm=admin`
+export ENV_FULLNODE_API_INFO=`lotus auth api-info --perm=admin`
+
+export MINER_API_INFO=`echo $ENV_MINER_API_INFO | awk '{split($0,a,"="); print a[2]}'`
+export FULLNODE_API_INFO=`echo $ENV_FULLNODE_API_INFO | awk '{split($0,a,"="); print a[2]}'`
+
+echo MINER_API_INFO=$MINER_API_INFO
+echo FULLNODE_API_INFO=$FULLNODE_API_INFO
 ```
 
-## Running the UI in Development Mode:
+8. Create the wallets needed for Boost
 
-1. Run the server
+```
+export DEFAULT_WALLET=`lotus wallet list | tail -1 | awk '{print $1}'`
+export COLLAT_WALLET=`lotus wallet new bls`
+export PUBMSG_WALLET=`lotus wallet new bls`
+export CLIENT_WALLET=`lotus wallet new bls`
+```
+
+9. Add funds to the wallets
 
 ```
-cd react
-npm install
-npm start
+lotus send --from $DEFAULT_WALLET $COLLAT_WALLET 10
+lotus send --from $DEFAULT_WALLET $PUBMSG_WALLET 10
+lotus send --from $DEFAULT_WALLET $CLIENT_WALLET 10
 ```
 
-2. Open UI
+Run this command repeatedly until each wallet you created has 10 FIL:
+```
+lotus wallet list
+```
+
+This should take about 10 seconds.
+
+10. Set the Publish Message Wallet as a control address on the miner
 
 ```
-http://localhost:3000
+lotus-miner actor control set --really-do-it $PUBMSG_WALLET
 ```
 
-## Running a devnet:
+11. Add funds into the Market Actor escrow for the client and Collateral wallets
+
+```
+lotus wallet market add --from $DEFAULT_WALLET --address $CLIENT_WALLET 5
+lotus wallet market add --address $COLLAT_WALLET 5
+```
 
-Follow the instructions in the [devnet guide](./documentation/devnet.md)
+12. Initialize Boost / Create Boost repository
+
+```
+boostd -vv init \
+  --api-sealer=$MINER_API_INFO \
+  --api-sector-index=$MINER_API_INFO \
+  --wallet-publish-storage-deals=$PUBMSG_WALLET \
+  --wallet-deal-collateral=$COLLAT_WALLET \
+  --max-staging-deals-bytes=2000000000
+```
+
+13. Build the Web UI
+```
+make react
+```
+
+14. Edit config to set a fixed listen address
+
+Edit `~/.boost/config.toml`
+
+Set the port in the `ListenAddresses` key to `50000`
+```
+[Libp2p]
+  ListenAddresses = ["/ip4/0.0.0.0/tcp/50000", "/ip6/::/tcp/0"]
+```
+
+15. Run Boost
+```
+boostd -vv run
+```
+
+Note the peer ID of the boost instance:
+```
+2022-06-10T09:32:28.819Z        INFO    boostd  boostd/run.go:114       Boost libp2p node listening     {"maddr": "{12D3KooWQNNWNiJ1mieEk9EHjDVF2qBc1FSjJGEzwjnMJzteApaW: [/ip4/172.17.0.2/tcp/50000 /ip4/127.0.0.1/tcp/50000]}"}
+```
+In this example: `12D3KooWQNNWNiJ1mieEk9EHjDVF2qBc1FSjJGEzwjnMJzteApaW`
+
+14. Set the peer ID and multi-address of the miner on chain
+```
+lotus-miner actor set-peer-id <peer id>
+lotus-miner actor set-addrs /ip4/127.0.0.1/tcp/50000
+```
+
+16. Open the Web UI
+
+Open http://localhost:8080 to see the Boost UI
+
+### Make a deal with Boost
+
+1. Initialize the Boost client
+```
+boost init
+```
+
+This will output the address of the wallet (it's safe to run the init command repeatedly).
+
+2. Send funds to the client wallet
+```
+lotus send --from=$DEFAULT_WALLET <client wallet> 10
+```
+
+3. Follow the guide at https://boost.filecoin.io/tutorials/how-to-store-files-with-boost-on-filecoin
+
+Note that above you already ran a command to export FULLNODE_API (and point it to your local devnet lotus daemon).
+
+Note also that the provider address is `t01000` and you will need to supply an appropriate `--storage-price` when using `boost deal` since the devnet has a minimum price. Alternatively, using "Settings" in the Boost web UI to set the deal price to zero.
+
+## Running Boost devnet in Docker
+
+### Building Docker images
+
+1. Select Lotus version, for example: `lotus_version=1.17.1-rc2`. It must be the tag name of [the Lotus git repo](https://github.com/filecoin-project/lotus/tags) without `v` prefix.
+
+2. Select Boost version, for example: `boost_version=1.3.0-rc1`.
+
+3. Build images
+
+```
+cd docker/devnet
+make build/all
+```
+
+If you need to build a different version, edit the `.env` file.
+
+### Start devnet docker stack
+
+1. Run
+
+```
+cd docker/devnet
+docker compose up -d
+```
+
+It will spin up `lotus`, `lotus-miner`, `boost`, `booster-http` and `demo-http-server` containers. All temporary data will be saved in `./data` folder.
+
+The initial setup could take up to 20 min or more as it needs to download Filecoin proof parameters. During the initial setup, it is normal to see error messages in the log. Containers are waiting for the lotus to be ready. It may timeout several times. Restart is expected to be managed by `docker`.
+
+2. Try opening the Boost GUI http://localhost:8080 . Devnet is ready to operate when the URL opens and indicates no errors on the startup page.
+
+You can inspect the status using `docker compose logs -f`.
+
+### Start monitoring docker stack
+
+```
+docker plugin install grafana/loki-docker-driver:latest --alias loki --grant-all-permissions
+
+cd docker/monitoring
+docker compose up -d
+```
+
+### Connect monitoring stack to devnet stack
+
+```
+docker network connect devnet tempo
+```
+
+### Explore Grafana / Tempo and search for traces
+
+http://localhost:3333
+
+### Making a deal
+
+The `boost` container is packed with `boost` and `lotus` clients. You can connect to the container with the command `docker compose exec boost /bin/bash` and follow instructions for [storing files with Boost guide](https://boost.filecoin.io/tutorials/how-to-store-files-with-boost-on-filecoin). But the recommended startup is to follow the semi-interactive demo first:
+
+```
+# Attach to a running boost container
+docker compose exec boost /bin/bash
+
+# Execute the demo script /app/sample/make-a-deal.sh
+root@83260455bbd2:/app# ./sample/make-a-deal.sh
+```
+
+### Accessing Lotus from localhost
+
+By default the [docker-compose.yaml](./docker-compose.yaml) does not expose any port of the `lotus` container. To access the `lotus` from a local machine:
+1. You can either expose `1234` in [docker-compose.yaml](./docker-compose.yaml) or find the IP of the `lotus` container using `docker inspect lotus | grep IPAddress` command.
+2. Get the `FULLNODE_API_INFO`
+```
+docker exec -it lotus lotus auth api-info --perm=admin
+FULLNODE_API_INFO=eyJ...ms4:/dns/lotus/tcp/1234/http
+```
+3. Change the `dns/lotus/tcp/1234/http` to `ip4/<127.0.0.1 or container's IP>/tcp/1234/http` for the use in `FULLNODE_API_INFO`.
+
+### Cleaning up
+
+To stop containers and drop everything:
+```
+docker compose down --rmi local
+
+rm -rf ./data
+
+rm -rf /var/tmp/filecoin-proof-parameters
+```
 
 ## License
 
diff --git a/build/openrpc/boost.json.gz b/build/openrpc/boost.json.gz
index 2124f961d..45408a8f2 100644
Binary files a/build/openrpc/boost.json.gz and b/build/openrpc/boost.json.gz differ
diff --git a/build/version.go b/build/version.go
index e11be0ee5..4283f6756 100644
--- a/build/version.go
+++ b/build/version.go
@@ -2,7 +2,7 @@ package build
 
 var CurrentCommit string
 
-const BuildVersion = "1.4.0-rc1"
+const BuildVersion = "1.4.0-rc2"
 
 func UserVersion() string {
 	return BuildVersion + CurrentCommit
diff --git a/cmd/boostd/dagstore.go b/cmd/boostd/dagstore.go
index 45bdbf349..57ec2265e 100644
--- a/cmd/boostd/dagstore.go
+++ b/cmd/boostd/dagstore.go
@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/filecoin-project/lotus/lib/tablewriter"
+	"github.com/ipfs/go-cid"
 
 	"github.com/fatih/color"
 	bapi "github.com/filecoin-project/boost/api"
@@ -25,6 +26,7 @@ var dagstoreCmd = &cli.Command{
 		dagstoreListShardsCmd,
 		dagstoreGcCmd,
 		dagstoreDestroyShardCmd,
+		dagstoreLookupCmd,
 	},
 }
 
@@ -309,3 +311,47 @@ var dagstoreDestroyShardCmd = &cli.Command{
 		return nil
 	},
 }
+
+var dagstoreLookupCmd = &cli.Command{
+	Name:      "lookup-piece-cid",
+	ArgsUsage: "[key]",
+	Usage:     "Performs a reverse lookup with payload CID to get Piece CID",
+	Aliases:   []string{"lpc"},
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:        "color",
+			Usage:       "use color in display output",
+			DefaultText: "depends on output being a TTY",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.IsSet("color") {
+			color.NoColor = !cctx.Bool("color")
+		}
+
+		if cctx.NArg() != 1 {
+			return fmt.Errorf("must provide a single payload CID")
+		}
+
+		napi, closer, err := bcli.GetBoostAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.ReqContext(cctx)
+
+		shardKey := cctx.Args().First()
+		payloadCid, err := cid.Parse(shardKey)
+		if err != nil {
+			return fmt.Errorf("Unable to parse the provided CID: %s", shardKey)
+		}
+		pieceCid, err := napi.BoostDagstorePiecesContainingMultihash(ctx, payloadCid.Hash())
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Given CID was found in the following pieces: %s", pieceCid)
+		return nil
+	},
+}
diff --git a/cmd/boostd/init.go b/cmd/boostd/init.go
index dd173b740..ac5dbddec 100644
--- a/cmd/boostd/init.go
+++ b/cmd/boostd/init.go
@@ -540,10 +540,6 @@ func initBoost(ctx context.Context, cctx *cli.Context, marketsRepo lotus_repo.Lo
 		return nil, fmt.Errorf("failed to parse wallet-deal-collateral: %s; err: %w", cctx.String("wallet-deal-collateral"), err)
 	}
 
-	if walletPSD.String() == walletCP.String() {
-		return nil, fmt.Errorf("wallets for PublishStorageDeals and deal collateral must be different")
-	}
-
 	if cctx.Int64("max-staging-deals-bytes") <= 0 {
 		return nil, fmt.Errorf("max size for staging deals area must be > 0 bytes")
 	}
@@ -700,8 +696,6 @@ func setBoostDealMakingCfg(bdm *config.DealmakingConfig, mktsCfg *lotus_config.S
 	bdm.MaxDealStartDelay = config.Duration(ldm.MaxDealStartDelay)
 	bdm.MaxProviderCollateralMultiplier = ldm.MaxProviderCollateralMultiplier
 	bdm.MaxStagingDealsBytes = ldm.MaxStagingDealsBytes
-	bdm.SimultaneousTransfersForStorage = ldm.SimultaneousTransfersForStorage
-	bdm.SimultaneousTransfersForRetrieval = ldm.SimultaneousTransfersForRetrieval
 	bdm.StartEpochSealingBuffer = ldm.StartEpochSealingBuffer
 	bdm.Filter = ldm.Filter
 	bdm.RetrievalFilter = ldm.RetrievalFilter
diff --git a/cmd/booster-http/run.go b/cmd/booster-http/run.go
index f2ed270c9..f9f336cd9 100644
--- a/cmd/booster-http/run.go
+++ b/cmd/booster-http/run.go
@@ -11,6 +11,7 @@ import (
 	"github.com/filecoin-project/boost/api"
 	bclient "github.com/filecoin-project/boost/api/client"
 	cliutil "github.com/filecoin-project/boost/cli/util"
+	"github.com/filecoin-project/boost/tracing"
 	"github.com/filecoin-project/dagstore/mount"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-jsonrpc"
@@ -67,10 +68,20 @@ var runCmd = &cli.Command{
 			Required: true,
 		},
 		&cli.StringFlag{
-			Name:     "api-sealer",
-			Usage:    "the endpoint for the sealer API",
+			Name:     "api-storage",
+			Usage:    "the endpoint for the storage node API",
 			Required: true,
 		},
+		&cli.BoolFlag{
+			Name:  "tracing",
+			Usage: "enables tracing of booster-http calls",
+			Value: false,
+		},
+		&cli.StringFlag{
+			Name:  "tracing-endpoint",
+			Usage: "the endpoint for the tracing exporter",
+			Value: "http://tempo:14268/api/traces",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.Bool("pprof") {
@@ -99,19 +110,30 @@ var runCmd = &cli.Command{
 		}
 		defer ncloser()
 
-		// Connect to the sealing API
-		sealingApiInfo := cctx.String("api-sealer")
-		sauth, err := storageAuthWithURL(sealingApiInfo)
+		// Connect to the storage API
+		storageApiInfo := cctx.String("api-storage")
+		sauth, err := storageAuthWithURL(storageApiInfo)
 		if err != nil {
-			return fmt.Errorf("parsing sealing API endpoint: %w", err)
+			return fmt.Errorf("parsing storage API endpoint: %w", err)
 		}
-		sealingService, sealerCloser, err := getMinerApi(ctx, sealingApiInfo)
+		storageService, storageCloser, err := getMinerApi(ctx, storageApiInfo)
 		if err != nil {
 			return fmt.Errorf("getting miner API: %w", err)
 		}
-		defer sealerCloser()
+		defer storageCloser()
+
+		// Instantiate the tracer and exporter
+		enableTracing := cctx.Bool("tracing")
+		var tracingStopper func(context.Context) error
+		if enableTracing {
+			tracingStopper, err = tracing.New("booster-http", cctx.String("tracing-endpoint"))
+			if err != nil {
+				return fmt.Errorf("failed to instantiate tracer: %w", err)
+			}
+			log.Info("Tracing exporter enabled")
+		}
 
-		maddr, err := sealingService.ActorAddress(ctx)
+		maddr, err := storageService.ActorAddress(ctx)
 		if err != nil {
 			return fmt.Errorf("getting miner actor address: %w", err)
 		}
@@ -129,17 +151,17 @@ var runCmd = &cli.Command{
 
 		// Create the store interface
 		var urls []string
-		lstor, err := paths.NewLocal(ctx, lr, sealingService, urls)
+		lstor, err := paths.NewLocal(ctx, lr, storageService, urls)
 		if err != nil {
 			return fmt.Errorf("creating new local store: %w", err)
 		}
-		storage := lotus_modules.RemoteStorage(lstor, sealingService, sauth, sealer.Config{
+		storage := lotus_modules.RemoteStorage(lstor, storageService, sauth, sealer.Config{
 			// TODO: Not sure if I need this, or any of the other fields in this struct
 			ParallelFetchLimit: 1,
 		})
 		// Create the piece provider and sector accessors
-		pp := sealer.NewPieceProvider(storage, sealingService, sealingService)
-		sa := sectoraccessor.NewSectorAccessor(dtypes.MinerAddress(maddr), sealingService, pp, fullnodeApi)
+		pp := sealer.NewPieceProvider(storage, storageService, storageService)
+		sa := sectoraccessor.NewSectorAccessor(dtypes.MinerAddress(maddr), storageService, pp, fullnodeApi)
 		allowIndexing := cctx.Bool("allow-indexing")
 		// Create the server API
 		sapi := serverApi{ctx: ctx, bapi: bapi, sa: sa}
@@ -176,6 +198,13 @@ var runCmd = &cli.Command{
 		// Sync all loggers.
 		_ = log.Sync() //nolint:errcheck
 
+		if enableTracing {
+			err = tracingStopper(ctx)
+			if err != nil {
+				return err
+			}
+		}
+
 		return nil
 	},
 }
@@ -198,8 +227,8 @@ type serverApi struct {
 
 var _ HttpServerApi = (*serverApi)(nil)
 
-func (s serverApi) PiecesContainingMultihash(mh multihash.Multihash) ([]cid.Cid, error) {
-	return s.bapi.BoostDagstorePiecesContainingMultihash(s.ctx, mh)
+func (s serverApi) PiecesContainingMultihash(ctx context.Context, mh multihash.Multihash) ([]cid.Cid, error) {
+	return s.bapi.BoostDagstorePiecesContainingMultihash(ctx, mh)
 }
 
 func (s serverApi) GetMaxPieceOffset(pieceCid cid.Cid) (uint64, error) {
@@ -269,7 +298,7 @@ func getMinerApi(ctx context.Context, ai string) (v0api.StorageMiner, jsonrpc.Cl
 		return nil, nil, fmt.Errorf("could not get DialArgs: %w", err)
 	}
 
-	log.Infof("Using sealing API at %s", addr)
+	log.Infof("Using storage API at %s", addr)
 	api, closer, err := client.NewStorageMinerRPCV0(ctx, addr, info.AuthHeader())
 	if err != nil {
 		return nil, nil, fmt.Errorf("creating miner service API: %w", err)
diff --git a/cmd/booster-http/server.go b/cmd/booster-http/server.go
index 1c49b25e4..457d78a44 100644
--- a/cmd/booster-http/server.go
+++ b/cmd/booster-http/server.go
@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/fatih/color"
+	"github.com/filecoin-project/boost/tracing"
 	"github.com/filecoin-project/dagstore/mount"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
@@ -46,7 +47,7 @@ type HttpServer struct {
 }
 
 type HttpServerApi interface {
-	PiecesContainingMultihash(mh multihash.Multihash) ([]cid.Cid, error)
+	PiecesContainingMultihash(ctx context.Context, mh multihash.Multihash) ([]cid.Cid, error)
 	GetMaxPieceOffset(pieceCid cid.Cid) (uint64, error)
 	GetPieceInfo(pieceCID cid.Cid) (*piecestore.PieceInfo, error)
 	IsUnsealed(ctx context.Context, sectorID abi.SectorNumber, offset abi.UnpaddedPieceSize, length abi.UnpaddedPieceSize) (bool, error)
@@ -147,6 +148,9 @@ func (s *HttpServer) handleIndex(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *HttpServer) handleByPayloadCid(w http.ResponseWriter, r *http.Request) {
+	ctx, span := tracing.Tracer.Start(r.Context(), "http.payload_cid")
+	defer span.End()
+
 	// Remove the path up to the payload cid
 	prefixLen := len(s.payloadBasePath())
 	if len(r.URL.Path) <= prefixLen {
@@ -166,7 +170,7 @@ func (s *HttpServer) handleByPayloadCid(w http.ResponseWriter, r *http.Request)
 	}
 
 	// Find all the pieces that contain the payload cid
-	pieces, err := s.api.PiecesContainingMultihash(payloadCid.Hash())
+	pieces, err := s.api.PiecesContainingMultihash(ctx, payloadCid.Hash())
 	if err != nil {
 		if isNotFoundError(err) {
 			msg := fmt.Sprintf("getting piece that contains payload CID '%s': %s", payloadCid, err.Error())
@@ -182,11 +186,8 @@ func (s *HttpServer) handleByPayloadCid(w http.ResponseWriter, r *http.Request)
 	// Just get the content of the first piece returned (if the client wants a
 	// different piece they can just call the /piece endpoint)
 	pieceCid := pieces[0]
-	ctx := r.Context()
 	content, err := s.getPieceContent(ctx, pieceCid)
-	if err == nil && isCar && r.Method != "HEAD" {
-		// Note: Getting the CAR content out of the piece is non-trivial, so
-		// we don't do it for HEAD requests
+	if err == nil && isCar {
 		content, err = s.getCarContent(pieceCid, content)
 	}
 	if err != nil {
@@ -233,9 +234,7 @@ func (s *HttpServer) handleByPieceCid(w http.ResponseWriter, r *http.Request) {
 	// Get a reader over the the piece
 	ctx := r.Context()
 	content, err := s.getPieceContent(ctx, pieceCid)
-	if err == nil && isCar && r.Method != "HEAD" {
-		// Note: Getting the CAR content out of the piece is non-trivial, so
-		// we don't do it for HEAD requests
+	if err == nil && isCar {
 		content, err = s.getCarContent(pieceCid, content)
 	}
 	if err != nil {
@@ -272,7 +271,7 @@ func serveContent(w http.ResponseWriter, r *http.Request, content io.ReadSeeker,
 	w.Header().Set("Content-Type", contentType)
 
 	if r.Method == "HEAD" {
-		// For an HTTP HEAD request we don't send any data (just headers)
+		// For an HTTP HEAD request ServeContent doesn't send any data (just headers)
 		http.ServeContent(w, r, "", time.Time{}, content)
 		alog("%s\tHEAD %s", color.New(color.FgGreen).Sprintf("%d", http.StatusOK), r.URL)
 		return
diff --git a/db/deals_test.go b/db/deals_test.go
index 85455759e..f2f4303f9 100644
--- a/db/deals_test.go
+++ b/db/deals_test.go
@@ -103,7 +103,7 @@ func TestDealsDBSearch(t *testing.T) {
 
 	start := time.Now()
 	db := NewDealsDB(sqldb)
-	deals, err := generateDeals(5)
+	deals, err := GenerateNDeals(5)
 	req.NoError(err)
 	t.Logf("generated %d deals in %s", len(deals), time.Since(start))
 
diff --git a/db/fixtures.go b/db/fixtures.go
index 15db3b1bf..6b6b0f1e1 100644
--- a/db/fixtures.go
+++ b/db/fixtures.go
@@ -20,10 +20,10 @@ import (
 var clientAddrs = []uint64{01312, 42134, 01322, 43242, 04212}
 
 func GenerateDeals() ([]types.ProviderDealState, error) {
-	return generateDeals(len(clientAddrs))
+	return GenerateNDeals(len(clientAddrs))
 }
 
-func generateDeals(count int) ([]types.ProviderDealState, error) {
+func GenerateNDeals(count int) ([]types.ProviderDealState, error) {
 	provAddr, err := address.NewActorAddress([]byte("f1523"))
 	if err != nil {
 		return nil, err
@@ -81,7 +81,7 @@ func generateDeals(count int) ([]types.ProviderDealState, error) {
 				InboundFilePath: fmt.Sprintf("/data/staging/inbound/file-%d.car", rand.Intn(10000)),
 				Transfer: types.Transfer{
 					Type:   "http",
-					Params: []byte(fmt.Sprintf("{url:'http://files.org/file%d.car'}", rand.Intn(1000))),
+					Params: []byte(fmt.Sprintf(`{"url":"http://files.org/file%d.car"}`, rand.Intn(1000))),
 					Size:   uint64(rand.Intn(10000)),
 				},
 				ChainDealID: abi.DealID(rand.Intn(10000)),
diff --git a/db/migrations/20220908122510_storagetagged_add_host.sql b/db/migrations/20220908122510_storagetagged_add_host.sql
new file mode 100644
index 000000000..1cc937324
--- /dev/null
+++ b/db/migrations/20220908122510_storagetagged_add_host.sql
@@ -0,0 +1,10 @@
+-- +goose Up
+-- +goose StatementBegin
+ALTER TABLE StorageTagged
+    ADD TransferHost TEXT;
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+SELECT 'down SQL query';
+-- +goose StatementEnd
diff --git a/db/migrations/20220908122516_storagetagged_set_host.go b/db/migrations/20220908122516_storagetagged_set_host.go
new file mode 100644
index 000000000..7766ccd27
--- /dev/null
+++ b/db/migrations/20220908122516_storagetagged_set_host.go
@@ -0,0 +1,58 @@
+package migrations
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/filecoin-project/boost/storagemarket/types"
+	"github.com/pressly/goose/v3"
+)
+
+func init() {
+	goose.AddMigration(UpSetStorageTaggedTransferHost, DownSetStorageTaggedTransferHost)
+}
+
+func UpSetStorageTaggedTransferHost(tx *sql.Tx) error {
+	errPrefix := "setting StorageTagged.TransferHost: "
+	qry := "SELECT Deals.ID, Deals.TransferType, Deals.TransferParams " +
+		"FROM Deals INNER JOIN StorageTagged " +
+		"ON Deals.ID = StorageTagged.DealUUID"
+	rows, err := tx.Query(qry)
+	if err != nil {
+		return fmt.Errorf(errPrefix+"getting deals from DB: %w", err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var id string
+		var xferType string
+		var params []byte
+		err := rows.Scan(&id, &xferType, &params)
+		if err != nil {
+			return fmt.Errorf(errPrefix+"scanning Deals row: %w", err)
+		}
+
+		dealErrPrefix := fmt.Sprintf(errPrefix+"deal %s: ", id)
+
+		xfer := types.Transfer{
+			Type:   xferType,
+			Params: params,
+		}
+		host, err := xfer.Host()
+		if err != nil {
+			log.Warnw(dealErrPrefix+"ignoring - couldn't parse transfer params %s: '%s': %s", xferType, params, err)
+			continue
+		}
+
+		_, err = tx.Exec("UPDATE StorageTagged SET TransferHost = ? WHERE DealUUID = ?", host, id)
+		if err != nil {
+			return fmt.Errorf(dealErrPrefix+"saving TransferHost to DB: %w", err)
+		}
+	}
+	return rows.Err()
+}
+
+func DownSetStorageTaggedTransferHost(tx *sql.Tx) error {
+	// This code is executed when the migration is rolled back.
+	// Do nothing because sqlite doesn't support removing a column.
+	return nil
+}
diff --git a/db/migrations_tests/storagetagged_set_host_test.go b/db/migrations_tests/storagetagged_set_host_test.go
new file mode 100644
index 000000000..7777309c1
--- /dev/null
+++ b/db/migrations_tests/storagetagged_set_host_test.go
@@ -0,0 +1,70 @@
+package migrations_tests
+
+import (
+	"context"
+	"fmt"
+	"github.com/filecoin-project/boost/db"
+	"github.com/filecoin-project/boost/db/migrations"
+	"github.com/filecoin-project/boost/storagemarket/types"
+	"github.com/pressly/goose/v3"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestStorageTaggedSetHost(t *testing.T) {
+	req := require.New(t)
+	ctx := context.Background()
+
+	sqldb := db.CreateTestTmpDB(t)
+	req.NoError(db.CreateAllBoostTables(ctx, sqldb, sqldb))
+
+	// Run migrations up to the one that adds the TransferHost field to StorageTagged
+	goose.SetBaseFS(migrations.EmbedMigrations)
+	req.NoError(goose.SetDialect("sqlite3"))
+	req.NoError(goose.UpTo(sqldb, ".", 20220908122510))
+
+	// Generate 2 deals
+	dealsDB := db.NewDealsDB(sqldb)
+	deals, err := db.GenerateNDeals(2)
+	req.NoError(err)
+
+	// Set the transfer params such that each deal has a different host
+	getHost := func(i int) string {
+		return fmt.Sprintf("files.org:%d", 1000+i)
+	}
+	for i, deal := range deals {
+		deal.Transfer = types.Transfer{
+			Type:   "http",
+			Params: []byte(fmt.Sprintf(`{"url":"http://%s/file.car"}`, getHost(i))),
+			Size:   uint64(1024),
+		}
+		err = dealsDB.Insert(ctx, &deal)
+		req.NoError(err)
+	}
+
+	// Simulate tagging a deal
+	taggedStorageDB := db.NewStorageDB(sqldb)
+	err = taggedStorageDB.Tag(ctx, deals[0].DealUuid, 1024, "")
+	req.NoError(err)
+
+	// Run the migration that reads the deal transfer params and sets
+	// StorageTagged.TransferHost
+	req.NoError(goose.UpByOne(sqldb, "."))
+
+	// Check that after migrating up, the host is set correctly
+	rows, err := sqldb.QueryContext(ctx, "SELECT TransferHost FROM StorageTagged")
+	req.NoError(err)
+	defer rows.Close() //nolint:errcheck
+
+	rowIdx := 0
+	for ; rows.Next(); rowIdx++ {
+		var host string
+		err := rows.Scan(&host)
+		req.NoError(err)
+		req.Equal(getHost(0), host)
+	}
+
+	// Even though there are two deals in DB, there is only one deal that is
+	// tagged, so there should only be one row
+	req.Equal(1, rowIdx)
+}
diff --git a/db/storage.go b/db/storage.go
index 240b64dcc..88fef71e8 100644
--- a/db/storage.go
+++ b/db/storage.go
@@ -26,10 +26,10 @@ func NewStorageDB(db *sql.DB) *StorageDB {
 	return &StorageDB{db: db}
 }
 
-func (s *StorageDB) Tag(ctx context.Context, dealUuid uuid.UUID, size uint64) error {
-	qry := "INSERT INTO StorageTagged (DealUUID, CreatedAt, TransferSize) "
-	qry += "VALUES (?, ?, ?)"
-	values := []interface{}{dealUuid, time.Now(), fmt.Sprintf("%d", size)}
+func (s *StorageDB) Tag(ctx context.Context, dealUuid uuid.UUID, size uint64, host string) error {
+	qry := "INSERT INTO StorageTagged (DealUUID, CreatedAt, TransferSize, TransferHost) "
+	qry += "VALUES (?, ?, ?, ?)"
+	values := []interface{}{dealUuid, time.Now(), fmt.Sprintf("%d", size), host}
 	_, err := s.db.ExecContext(ctx, qry, values...)
 	return err
 }
@@ -112,8 +112,22 @@ func (s *StorageDB) Logs(ctx context.Context) ([]StorageLog, error) {
 	return storageLogs, nil
 }
 
+func (s *StorageDB) TotalTaggedForHost(ctx context.Context, host string) (uint64, error) {
+	return s.totalTagged(ctx, host)
+}
+
 func (s *StorageDB) TotalTagged(ctx context.Context) (uint64, error) {
-	rows, err := s.db.QueryContext(ctx, "SELECT TransferSize FROM StorageTagged")
+	return s.totalTagged(ctx, "")
+}
+
+func (s *StorageDB) totalTagged(ctx context.Context, host string) (uint64, error) {
+	qry := "SELECT TransferSize FROM StorageTagged"
+	var args []interface{}
+	if host != "" {
+		qry += " WHERE TransferHost = ?"
+		args = append(args, host)
+	}
+	rows, err := s.db.QueryContext(ctx, qry, args...)
 	if err != nil {
 		return 0, fmt.Errorf("getting total tagged: %w", err)
 	}
diff --git a/db/storage_test.go b/db/storage_test.go
index 543673283..26d859801 100644
--- a/db/storage_test.go
+++ b/db/storage_test.go
@@ -5,8 +5,8 @@ import (
 	"errors"
 	"testing"
 
+	"github.com/filecoin-project/boost/db/migrations"
 	"github.com/google/uuid"
-
 	"github.com/stretchr/testify/require"
 )
 
@@ -16,6 +16,7 @@ func TestStorageDB(t *testing.T) {
 
 	sqldb := CreateTestTmpDB(t)
 	require.NoError(t, CreateAllBoostTables(ctx, sqldb, sqldb))
+	req.NoError(migrations.Migrate(sqldb))
 
 	db := NewStorageDB(sqldb)
 
@@ -28,12 +29,20 @@ func TestStorageDB(t *testing.T) {
 	req.True(errors.Is(err, ErrNotFound))
 	req.Equal(uint64(0), amt)
 
-	err = db.Tag(ctx, dealUUID, 1111)
+	err = db.Tag(ctx, dealUUID, 1111, "foo.bar:1234")
+	req.NoError(err)
+
+	dealUUID2 := uuid.New()
+	err = db.Tag(ctx, dealUUID2, 2222, "my.host:5678")
 	req.NoError(err)
 
 	total, err := db.TotalTagged(ctx)
 	req.NoError(err)
-	req.Equal(uint64(1111), total)
+	req.Equal(uint64(3333), total)
+
+	total, err = db.TotalTaggedForHost(ctx, "my.host:5678")
+	req.NoError(err)
+	req.Equal(uint64(2222), total)
 
 	amt, err = db.Untag(ctx, dealUUID)
 	req.NoError(err)
diff --git a/docker/devnet/.env b/docker/devnet/.env
new file mode 100644
index 000000000..e1ebb96a2
--- /dev/null
+++ b/docker/devnet/.env
@@ -0,0 +1,6 @@
+DOCKER_USER=filecoin
+LOTUS_IMAGE=${DOCKER_USER}/lotus-dev:1.17.1-rc2
+LOTUS_MINER_IMAGE=${DOCKER_USER}/lotus-miner-dev:1.17.1-rc2
+BOOST_IMAGE=${DOCKER_USER}/boost-dev:dev
+BOOSTER_HTTP_IMAGE=${DOCKER_USER}/booster-http-dev:dev
+BOOST_GUI_IMAGE=${DOCKER_USER}/boost-gui:dev
diff --git a/docker/devnet/.env-stable b/docker/devnet/.env-stable
new file mode 100644
index 000000000..6db690f48
--- /dev/null
+++ b/docker/devnet/.env-stable
@@ -0,0 +1,5 @@
+DOCKER_USER=filecoin
+LOTUS_IMAGE=${DOCKER_USER}/lotus-dev:1.17.1-rc2
+LOTUS_MINER_IMAGE=${DOCKER_USER}/lotus-miner-dev:1.17.1-rc2
+BOOST_IMAGE=${DOCKER_USER}/boost-dev:1.3.0-rc1
+BOOST_GUI_IMAGE=${DOCKER_USER}/boost-gui:1.3.0-rc1
diff --git a/docker/devnet/.gitignore b/docker/devnet/.gitignore
new file mode 100644
index 000000000..1269488f7
--- /dev/null
+++ b/docker/devnet/.gitignore
@@ -0,0 +1 @@
+data
diff --git a/docker/devnet/Makefile b/docker/devnet/Makefile
new file mode 100644
index 000000000..7cad4af29
--- /dev/null
+++ b/docker/devnet/Makefile
@@ -0,0 +1,57 @@
+##################################################################################
+lotus_version?=1.17.1-rc2
+boost_version?=1.3.0-rc1
+docker_user?=filecoin
+
+lotus_test_image=$(docker_user)/lotus-test:$(lotus_version)
+##################################################################################
+lotus-$(lotus_version):
+	git clone --depth 1 --branch v$(lotus_version) https://github.com/filecoin-project/lotus $@
+
+prepare/lotus-test: | lotus-$(lotus_version)
+	cd lotus-$(lotus_version) && docker build -f Dockerfile.lotus --target lotus-test -t $(lotus_test_image) .
+.PHONY: prepare/lotus-test
+##################################################################################
+build/%: prepare/lotus-test
+	cd $* && make dbuild
+../../build/.update-modules: 
+	cd ../../ && make build/.update-modules	
+build/boost: ../../build/.update-modules prepare/lotus-test
+	cd boost && make dbuild
+push/%: prepare/lotus-test
+	cd $* && make dpush	
+##################################################################################
+build/all: build/lotus build/lotus-miner build/boost build/boost-gui build/booster-http
+.PHONY: build/all
+##################################################################################
+push/all: push/lotus push/lotus-miner push/boost push/boost-gui push/booster-http
+.PHONY: push/all
+##################################################################################
+clean: clean/lotus-test
+.PHONY: clean
+
+clean/lotus-test:
+	rm -rf lotus-$(lotus_version)
+.PHONY: clean/lotus-test
+
+.EXPORT_ALL_VARIABLES:
+##################################################################################
+start: 
+	docker compose up -d
+	docker compose logs -f
+.PHONY: start
+##################################################################################
+ssh/boost: 
+	docker compose exec boost /bin/bash
+.PHONY: ssh/boost
+##################################################################################
+clean-stack: clean/docker
+	rm -rf data
+.PHONY: clean
+clean/all: clean
+	rm -rf /var/tmp/filecoin-proof-parameters
+.PHONY: clean/all
+clean/docker:
+	docker compose down
+.PHONY: clean/docker
+##################################################################################
diff --git a/docker/devnet/boost/Dockerfile.source b/docker/devnet/boost/Dockerfile.source
new file mode 100644
index 000000000..9c4315ee4
--- /dev/null
+++ b/docker/devnet/boost/Dockerfile.source
@@ -0,0 +1,77 @@
+#########################################################################################
+## docker will invoke this file from ../../.. dir in order to access the code
+#########################################################################################
+ARG LOTUS_TEST_IMAGE=filecoin/lotus-test:latest
+FROM ${LOTUS_TEST_IMAGE} as lotus-dev
+#########################################################################################
+FROM golang:1.18-bullseye as builder
+
+RUN apt update && apt install -y \
+      build-essential \
+      bzr pkg-config \
+      clang \
+      curl \
+      gcc git \
+      hwloc \
+      jq \
+      libhwloc-dev wget \
+      mesa-opencl-icd \
+      ocl-icd-opencl-dev
+
+WORKDIR /go/src/
+
+COPY Makefile /go/src/
+##############################################
+# prebuild filecoin-ffi
+COPY extern /go/src/extern
+COPY build /go/src/build
+COPY .git/modules/extern/filecoin-ffi /go/src/.git/modules/extern/filecoin-ffi
+
+RUN make build/.filecoin-install
+##############################################
+COPY . /go/src
+##############################################
+RUN --mount=type=cache,target=/root/.cache/go-build \
+    --mount=type=cache,target=/go/pkg/mod \
+      make debug
+#########################################################################################
+FROM ubuntu:20.04 as runner
+
+RUN apt update && apt install -y \
+      curl \
+      hwloc \
+      jq
+
+ARG BUILD_VERSION=0.1
+
+LABEL org.opencontainers.image.version=$BUILD_VERSION \
+      org.opencontainers.image.authors="Boost Dev Team" \
+      name="boost-dev" \
+      maintainer="Boost Dev Team" \
+      vendor="Boost Dev Team" \
+      version=$BUILD_VERSION \
+      release=$BUILD_VERSION \
+      summary="This image is used to host the boost-dev storage provider" \
+      description="This image is used to host the boost-dev storage provider" 
+
+WORKDIR /app
+ENV BOOST_PATH /var/lib/boost
+VOLUME /var/lib/boost
+EXPOSE 8080  
+
+## Fix missing lib libhwloc.so.5
+RUN ls -1 /lib/*/libhwloc.so.* | head -n 1 | xargs -n1 -I {} ln -s {} /lib/libhwloc.so.5
+
+COPY --from=lotus-dev /usr/local/bin/lotus /usr/local/bin/
+COPY --from=lotus-dev /usr/local/bin/lotus-miner /usr/local/bin/
+
+COPY --from=builder /go/src/boostd /usr/local/bin/
+COPY --from=builder /go/src/boost /usr/local/bin/
+COPY --from=builder /go/src/boostx /usr/local/bin/
+## Smoke test for the boost and lotus
+RUN lotus -v && boost -v 
+
+COPY docker/devnet/boost/entrypoint.sh /app/
+COPY docker/devnet/boost/sample/* /app/sample/
+
+ENTRYPOINT ["./entrypoint.sh"]
diff --git a/docker/devnet/boost/Dockerfile.stable b/docker/devnet/boost/Dockerfile.stable
new file mode 100644
index 000000000..186e2c034
--- /dev/null
+++ b/docker/devnet/boost/Dockerfile.stable
@@ -0,0 +1,64 @@
+#########################################################################################
+#########################################################################################
+ARG LOTUS_TEST_IMAGE=filecoin/lotus-test:latest
+FROM ${LOTUS_TEST_IMAGE} as lotus-dev
+#########################################################################################
+FROM golang:1.18-bullseye as builder
+
+RUN apt update && apt install -y \
+      build-essential \
+      bzr pkg-config \
+      clang \
+      curl \
+      gcc git \
+      hwloc \
+      jq \
+      libhwloc-dev wget \
+      mesa-opencl-icd \
+      ocl-icd-opencl-dev
+
+WORKDIR /go/src/
+
+ARG BUILD_VERSION=0.1
+RUN git clone --depth 1 --branch v${BUILD_VERSION} https://github.com/filecoin-project/boost
+
+RUN cd boost && make debug
+#########################################################################################
+FROM ubuntu:20.04 as runner
+
+RUN apt update && apt install -y \
+      curl \
+      hwloc \
+      jq
+
+ARG BUILD_VERSION=0.1
+
+LABEL org.opencontainers.image.version=$BUILD_VERSION \
+      org.opencontainers.image.authors="Boost Dev Team" \
+      name="boost-dev" \
+      maintainer="Boost Dev Team" \
+      vendor="Boost Dev Team" \
+      version=$BUILD_VERSION \
+      release=$BUILD_VERSION \
+      summary="This image is used to host the boost-dev storage provider" \
+      description="This image is used to host the boost-dev storage provider" 
+
+WORKDIR /app
+ENV BOOST_PATH /var/lib/boost
+VOLUME /var/lib/boost
+EXPOSE 8080  
+
+COPY --from=builder /go/src/boost/boostd /usr/local/bin/
+COPY --from=builder /go/src/boost/boost /usr/local/bin/
+COPY --from=builder /go/src/boost/boostx /usr/local/bin/
+COPY --from=lotus-dev /usr/local/bin/lotus /usr/local/bin/
+COPY --from=lotus-dev /usr/local/bin/lotus-miner /usr/local/bin/
+## Fix missing lib libhwloc.so.5
+RUN ls -1 /lib/x86_64-linux-gnu/libhwloc.so.* | head -n 1 | xargs -n1 -I {} ln -s {} /lib/x86_64-linux-gnu/libhwloc.so.5
+## Smoke test for the boost and lotus
+RUN lotus -v && boost -v 
+
+COPY entrypoint.sh /app/
+COPY sample/* /app/sample/
+
+ENTRYPOINT ["./entrypoint.sh"]
diff --git a/docker/devnet/boost/Makefile b/docker/devnet/boost/Makefile
new file mode 100644
index 000000000..ec4d22a89
--- /dev/null
+++ b/docker/devnet/boost/Makefile
@@ -0,0 +1,19 @@
+#####################################################################################
+service=$(docker_user)/boost-dev
+version=dev
+########### DOCKER ##################################################################
+tag=$(service):$(version)
+rootdir=$(realpath .)
+
+dbuild: 
+	DOCKER_BUILDKIT=1 docker build --build-arg LOTUS_TEST_IMAGE=$(lotus_test_image) \
+		-t $(tag) $(docker_args) -f Dockerfile.source $(rootdir)/../../../
+
+dpush: dbuild
+	docker push $(tag)
+
+dscan: dbuild
+	docker scan --accept-license $(tag)		
+#####################################################################################
+.PHONY:
+	dbuild dpush dscan
diff --git a/docker/devnet/boost/entrypoint.sh b/docker/devnet/boost/entrypoint.sh
new file mode 100755
index 000000000..a76c7362e
--- /dev/null
+++ b/docker/devnet/boost/entrypoint.sh
@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+set -e
+
+echo Wait for lotus is ready ...
+lotus wait-api
+echo Wait for lotus-miner is ready ...
+lotus-miner wait-api
+echo BOOST_PATH=$BOOST_PATH
+export DEFAULT_WALLET=`lotus wallet default`
+export FULLNODE_API_INFO=`lotus auth api-info --perm=admin | cut -f2 -d=`
+export MINER_API_INFO=`lotus-miner auth api-info --perm=admin | cut -f2 -d=`
+
+if [ ! -f $BOOST_PATH/.init.boost ]; then
+	echo Init wallets ...
+    export COLLAT_WALLET=`lotus wallet new bls`
+    export PUBMSG_WALLET=`lotus wallet new bls`
+    export CLIENT_WALLET=`lotus wallet new bls`
+	echo MINER_API_INFO=$MINER_API_INFO
+	echo FULLNODE_API_INFO=$FULLNODE_API_INFO
+	echo PUBMSG_WALLET=$PUBMSG_WALLET
+	echo COLLAT_WALLET=$COLLAT_WALLET
+
+    lotus send --from $DEFAULT_WALLET $COLLAT_WALLET 10
+    lotus send --from $DEFAULT_WALLET $PUBMSG_WALLET 10
+    lotus send --from $DEFAULT_WALLET $CLIENT_WALLET 10
+    lotus wallet market add --from $DEFAULT_WALLET --address $CLIENT_WALLET 5
+    lotus wallet market add --address $COLLAT_WALLET 5
+
+	until lotus-miner actor control set --really-do-it ${PUBMSG_WALLET}; do echo Waiting for storage miner API ready ...; sleep 1; done
+
+	echo Init boost on first run ...
+
+	boostd -vv --boost-repo $BOOST_PATH init --api-sealer=$MINER_API_INFO  \
+		--api-sector-index=$MINER_API_INFO   \
+		--wallet-publish-storage-deals=$PUBMSG_WALLET   \
+		--wallet-deal-collateral=$COLLAT_WALLET   \
+		--max-staging-deals-bytes=2000000000
+	
+	# echo exit code: $?
+	
+	echo Setting port in boost config...
+	sed -i 's|ip4/0.0.0.0/tcp/0|ip4/0.0.0.0/tcp/50000|g' $BOOST_PATH/config.toml
+	
+	echo Done
+	touch $BOOST_PATH/.init.boost
+fi
+
+if [ ! -f $BOOST_PATH/.register.boost ]; then
+	echo Temporary starting boost to get maddr...
+	
+	boostd -vv run &> $BOOST_PATH/boostd.log &
+	BOOST_PID=`echo $!`
+	echo Got boost PID = $BOOST_PID
+
+	until cat $BOOST_PATH/boostd.log | grep maddr; do echo "Waiting for boost..."; sleep 1; done
+	echo Looks like boost started and initialized...
+	
+	echo Registering to lotus-miner...
+	MADDR=`cat $BOOST_PATH/boostd.log | grep maddr | cut -f3 -d"{" | cut -f1 -d:`
+	echo Got maddr=${MADDR}
+	
+	lotus-miner actor set-peer-id ${MADDR}
+	lotus-miner actor set-addrs /dns/boost/tcp/50000
+	echo Registered
+
+	touch $BOOST_PATH/.register.boost
+	echo Try to stop boost...
+    kill -15 $BOOST_PID || kill -9 $BOOST_PID
+	rm -f $BOOST_PATH/boostd.log
+	echo Super. DONE! Boostd is now configured and will be started soon
+fi
+
+echo Starting boost in dev mode...
+exec boostd -vv run
+
diff --git a/docker/devnet/boost/sample/make-a-deal.sh b/docker/devnet/boost/sample/make-a-deal.sh
new file mode 100755
index 000000000..e95277d76
--- /dev/null
+++ b/docker/devnet/boost/sample/make-a-deal.sh
@@ -0,0 +1,138 @@
+#!/usr/bin/env bash
+###################################################################################
+# sample demo script for making a deal with boost client
+###################################################################################
+set -e
+# colors
+cb="\e[1m"
+ci="\e[3m" 
+cn="\e[0m"
+###################################################################################
+printf "\n
+###################################################################################\n \
+Hello to the demo script that makes a storage deal using the boost client\n \
+###################################################################################\n \
+1. The boost client needs to know how to connect to the lotus instance. \
+We need to set ${cb}FULLNODE_API_INFO${cn} env var. We have the lotus client here that will provide a connection token.\n \
+ : ${ci}lotus auth api-info --perm=admin${cn} - returns lotus connection token \n\n"
+read -rsp $'Press any key to export variable...\n' -n1 key
+export `lotus auth api-info --perm=admin`
+
+printf "\nExported FULLNODE_API_INFO=$FULLNODE_API_INFO\n \
+###################################################################################\n"
+###################################################################################
+printf "2. The boost client needs to be initialized by calling \n${ci}boost init${cn} \n\n"
+read -rsp $'Press any key to execute it...\n\n' -n1 key
+
+boost init
+
+printf "\n\nGreat. Boost client has been initialized.\n \
+###################################################################################\n"
+###################################################################################
+printf "3. Now add some funds from lotus to boost wallet. We will use the lotus client:\n\n \
+ : ${ci}lotus wallet default${cn} - returns default lotus wallet\n \
+ : ${ci}boost wallet default${cn} - returns default wallet for the current boost client actor\n \
+ : ${ci}lotus send --from=`lotus wallet default` `boost wallet default` 10${cn} - sends 10 FIL\n"
+read -rsp $'Press any key to execute it...\n\n' -n1 key
+
+lotus send --from=`lotus wallet default` `boost wallet default` 10
+
+printf "\n\nDone. Funds transfer was initiated\n \
+###################################################################################\n"
+###################################################################################
+printf "4. Now add some funds to the market actor\n \
+ : ${ci}boostx market-add 1${cn}\n\n"
+read -rsp $'Press any key to execute it...\n' -n1 key
+
+until boostx market-add 1; do printf "\nOpps, maybe funds not added yet.\nNeed to wait some time. \n"; read -rsp $'Press any key to try again...\n' -n1 key; done
+
+printf "\n\nYes. We can make a deal now.\n \
+###################################################################################\n"
+###################################################################################
+printf "5. Let's generate a sample file in ${ci}/app/public/sample.txt${cn}. We will use it as a demo file.\n\n"
+read -rsp $'Press any key to generate it...\n\n' -n1 key
+rm -f /app/public/sample.txt 
+for i in {1..57}; do echo "Hi Boost, $i times" >> /app/public/sample.txt; done
+
+printf "\n\nFile content:\n\n"
+cat /app/public/sample.txt
+printf "\n\n \
+###################################################################################\n"
+###################################################################################
+
+printf "6. After that, you need to generate a car file for data you want to store on Filecoin (${ci}/app/public/sample.txt${cn}), \
+and note down its ${ci}payload-cid${cn}. \
+We will use the ${ci}boostx${cn} utility\n \
+ : ${ci}boostx generate-car /app/public/sample.txt /app/public/sample.car${cn}\n\n"
+read -rsp $'Press any key to execute it...\n\n' -n1 key
+
+boostx generate-car /app/public/sample.txt /app/public/sample.car
+
+PAYLOAD_CID=`boostx generate-car /app/public/sample.txt /app/public/sample.car | grep CID | cut -d: -f2 | xargs`
+printf "\n\nDone. We noted payload-cid = ${ci}$PAYLOAD_CID${cn}\n \
+###################################################################################\n"
+###################################################################################
+printf "7. Then you need to calculate the commp and piece size for the generated car file:\n \
+ : ${ci}boostx commp /app/public/sample.car${cn}\n\n"
+read -rsp $'Press any key to execute it...\n\n' -n1 key
+
+boostx commp /app/public/sample.car
+
+COMMP_CID=`boostx commp /app/public/sample.car 2> /dev/null | grep CID | cut -d: -f2 | xargs`
+PIECE=`boostx commp /app/public/sample.car 2> /dev/null | grep Piece | cut -d: -f2 | xargs`
+CAR=`boostx commp /app/public/sample.car 2> /dev/null | grep Car | cut -d: -f2 | xargs`
+printf "\n\nYes. We also have remembered these values:\n \
+Commp-cid = $COMMP_CID \n \
+Piece size = $PIECE \n \
+Car size = $CAR \n \
+###################################################################################\n"
+###################################################################################
+printf "8. That's it. We are ready to make the deal. \n \
+ : ${ci}boost deal --verified=false --provider=t01000 \
+--http-url=http://demo-http-server/sample.car \
+--commp=$COMMP_CID --car-size=$CAR --piece-size=$PIECE \
+--payload-cid=$PAYLOAD_CID --storage-price 20000000000\n\n${cn}"
+read -rsp $'Press any key to make the deal...\n\n' -n1 key
+
+until boost deal --verified=false \
+           --provider=t01000 \
+           --http-url=http://demo-http-server/sample.car \
+           --commp=$COMMP_CID \
+           --car-size=$CAR \
+           --piece-size=$PIECE \
+           --payload-cid=$PAYLOAD_CID --storage-price 20000000000
+do  
+    printf "\nThe error has occured. Perhaps we should wait some time for funds to arrive into the market account.\n\n" 
+    read -rsp $'Press any key to check the boost wallet...\n\n' -n1 key
+    boost init
+    read -rsp $'\n\nPress any key to try making the deal again...\n' -n1 key 
+done           
+
+printf "\n\n   ${cb}Congrats! You have made it.${cn}\n\n \
+###################################################################################\n"
+###################################################################################"
+printf "9. Deal has been made, and it will be published automatically after some time, but you can do it manually using boost's graphql API\n \
+: ${ci}curl -X POST -H \"Content-Type: application/json\" -d '{\"query\":\"mutation { dealPublishNow }\"}' http://localhost:8080/graphql/query ${cn}\n\n"
+read -rsp $'Press any key to publish the deal...\n\n' -n1 key
+
+curl -X POST -H "Content-Type: application/json" -d '{"query":"mutation { dealPublishNow }"}' http://localhost:8080/graphql/query | jq
+printf "\nDone.\n\n \
+###################################################################################\n"
+###################################################################################
+printf "10. To retrieve the file from the ${cb}lotus${cn} system you can use \n\
+${ci}lotus client retrieve${cn} or ${ci}lotus client cat${cn} commands.\n\
+: ${ci}lotus client cat --miner t01000 $PAYLOAD_CID ${cn}\n\n"
+
+read -rsp $'Press any key to show the file content...\n\n' -n1 key
+until lotus client cat --miner t01000 $PAYLOAD_CID 
+do  
+    printf "\nFile publishing may take time, please wait some time until the deal is finished and try again.\n\n" 
+    read -rsp $'Press any key to try again...\n' -n1 key 
+done
+
+printf "\n\nIf you see a file content you have just completed the demo. You have succesfully:\n\n\
+  1) initiated the boost client\n\
+  2) prepared sample file\n\
+  3) sent the sample file to the Filecoin devnet\n\
+  4) retrieved the content of the file from it.\n\n\
+More info at ${cb}https://boost.filecoin.io${cn} or ${cb}https://github.com/filecoin-project/boost${cn}.\n\n\n"
diff --git a/docker/devnet/booster-http/Dockerfile.source b/docker/devnet/booster-http/Dockerfile.source
new file mode 100644
index 000000000..6ff59554c
--- /dev/null
+++ b/docker/devnet/booster-http/Dockerfile.source
@@ -0,0 +1,59 @@
+#########################################################################################
+## docker will invoke this file from ../../.. dir in order to access the code
+#########################################################################################
+ARG LOTUS_TEST_IMAGE=filecoin/lotus-test:latest
+FROM ${LOTUS_TEST_IMAGE} as lotus-dev
+#########################################################################################
+FROM golang:1.18-bullseye as builder
+
+RUN apt update && apt install -y \
+      build-essential \
+      bzr pkg-config \
+      clang \
+      curl \
+      gcc git \
+      hwloc \
+      jq \
+      libhwloc-dev wget \
+      mesa-opencl-icd \
+      ocl-icd-opencl-dev
+
+WORKDIR /go/src/
+
+# copy src
+COPY . /go/src/
+
+RUN make booster-http debug
+#########################################################################################
+FROM ubuntu:20.04 as runner
+
+RUN apt update && apt install -y \
+      curl \
+      hwloc \
+      jq
+
+ARG BUILD_VERSION=0.1
+
+LABEL org.opencontainers.image.version=$BUILD_VERSION \
+      org.opencontainers.image.authors="Boost Dev Team" \
+      name="booster-http-dev" \
+      maintainer="Boost Dev Team" \
+      vendor="Boost Dev Team" \
+      version=$BUILD_VERSION \
+      release=$BUILD_VERSION \
+      summary="This image is used to host booster-http-dev" \
+      description="This image is used to host booster-http-dev" 
+
+WORKDIR /app
+EXPOSE 7777  
+
+COPY --from=builder /go/src/booster-http /usr/local/bin/
+COPY --from=builder /go/src/boostd /usr/local/bin/
+COPY --from=lotus-dev /usr/local/bin/lotus /usr/local/bin/
+COPY --from=lotus-dev /usr/local/bin/lotus-miner /usr/local/bin/
+## Fix missing lib libhwloc.so.5
+RUN ls -1 /lib/x86_64-linux-gnu/libhwloc.so.* | head -n 1 | xargs -n1 -I {} ln -s {} /lib/x86_64-linux-gnu/libhwloc.so.5
+
+COPY docker/devnet/booster-http/entrypoint.sh /app/
+
+ENTRYPOINT ["./entrypoint.sh"]
diff --git a/docker/devnet/booster-http/Makefile b/docker/devnet/booster-http/Makefile
new file mode 100644
index 000000000..3259f9b5c
--- /dev/null
+++ b/docker/devnet/booster-http/Makefile
@@ -0,0 +1,19 @@
+#####################################################################################
+service=$(docker_user)/booster-http-dev
+version=dev
+########### DOCKER ##################################################################
+tag=$(service):$(version)
+rootdir=$(realpath .)
+
+dbuild: 
+	docker build --build-arg LOTUS_TEST_IMAGE=$(lotus_test_image) \
+		-t $(tag) -f Dockerfile.source $(rootdir)/../../../
+
+dpush: dbuild
+	docker push $(tag)
+
+dscan: dbuild
+	docker scan --accept-license $(tag)		
+#####################################################################################
+.PHONY:
+	dbuild dpush dscan
diff --git a/docker/devnet/booster-http/entrypoint.sh b/docker/devnet/booster-http/entrypoint.sh
new file mode 100755
index 000000000..7bc51736f
--- /dev/null
+++ b/docker/devnet/booster-http/entrypoint.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -e
+
+export FULLNODE_API_INFO=`lotus auth api-info --perm=admin | cut -f2 -d=`
+export MINER_API_INFO=`lotus-miner auth api-info --perm=admin | cut -f2 -d=`
+export BOOST_API_INFO=`boostd auth api-info --perm=admin | cut -f2 -d=`
+
+echo $FULLNODE_API_INFO
+echo $MINER_API_INFO
+echo $BOOST_API_INFO
+
+echo Starting booster-http...
+exec booster-http run --api-boost=$BOOST_API_INFO --api-fullnode=$FULLNODE_API_INFO --api-storage=$MINER_API_INFO --tracing
diff --git a/docker/devnet/docker-compose.yaml b/docker/devnet/docker-compose.yaml
new file mode 100644
index 000000000..d00843b75
--- /dev/null
+++ b/docker/devnet/docker-compose.yaml
@@ -0,0 +1,91 @@
+version: '3.8'
+
+x-logging:
+  &default-logging
+  options:
+    max-size: '20m'
+    max-file: '3'
+  driver: json-file
+
+networks:
+  default:
+    name: devnet
+
+services:
+  lotus:
+    container_name: lotus
+    image: ${LOTUS_IMAGE}
+    # ports:
+    #   - "1234:1234"
+    environment:
+      - LOTUS_API_LISTENADDRESS=/dns/lotus/tcp/1234/http
+    restart: unless-stopped
+    logging: *default-logging
+    volumes:
+      - ./data/lotus:/var/lib/lotus:rw
+      - ./data/genesis:/var/lib/genesis:rw
+      - /var/tmp/filecoin-proof-parameters:/var/tmp/filecoin-proof-parameters:rw
+
+  lotus-miner:
+    container_name: lotus-miner
+    image: ${LOTUS_MINER_IMAGE}
+    # ports:
+    #   - "2345:2345"
+    environment:
+      - LOTUS_API_LISTENADDRESS=/dns/lotus-miner/tcp/2345/http
+      - LOTUS_API_REMOTELISTENADDRESS=lotus-miner:2345
+      - LOTUS_SEALING_BATCHPRECOMMITS=false
+      - LOTUS_SEALING_AGGREGATECOMMITS=false
+      - LOTUS_SUBSYSTEMS_ENABLEMARKETS=false
+      - LOTUS_SEALING_WAITDEALSDELAY=20s
+    restart: unless-stopped
+    logging: *default-logging
+    volumes:
+      - ./data/lotus-miner:/var/lib/lotus-miner:rw
+      - ./data/lotus:/var/lib/lotus:ro
+      - ./data/genesis:/var/lib/genesis:ro
+      - /var/tmp/filecoin-proof-parameters:/var/tmp/filecoin-proof-parameters:rw
+
+  boost:
+    container_name: boost
+    image: ${BOOST_IMAGE}
+    ports:
+      - "8080:8080"
+    environment:
+      - LOTUS_API_LISTENADDRESS=/dns/boost/tcp/1288/http
+      - LOTUS_PATH=/var/lib/lotus
+      - LOTUS_MINER_PATH=/var/lib/lotus-miner
+      - LOTUS_TRACING_ENABLED=true
+      - LOTUS_TRACING_SERVICENAME=boostd
+      - LOTUS_TRACING_ENDPOINT=http://tempo:14268/api/traces
+    restart: unless-stopped
+    logging: *default-logging
+    volumes:
+      - ./data/boost:/var/lib/boost:rw
+      - ./data/lotus:/var/lib/lotus:ro
+      - ./data/lotus-miner:/var/lib/lotus-miner:ro
+      - ./data/sample:/app/public:rw
+
+  booster-http:
+    container_name: booster-http
+    image: ${BOOSTER_HTTP_IMAGE}
+    ports:
+      - "7777:7777"
+    environment:
+      - BOOST_PATH=/var/lib/boost
+      - LOTUS_PATH=/var/lib/lotus
+      - LOTUS_MINER_PATH=/var/lib/lotus-miner
+    restart: unless-stopped
+    logging: *default-logging
+    volumes:
+      - ./data/boost:/var/lib/boost:ro
+      - ./data/lotus:/var/lib/lotus:ro
+      - ./data/lotus-miner:/var/lib/lotus-miner:ro
+
+  demo-http-server:
+    container_name: demo-http-server
+    image: nginx:1.23-alpine
+    restart: unless-stopped
+    logging: *default-logging
+    volumes:
+      - ./data/sample:/usr/share/nginx/html:ro
diff --git a/docker/devnet/lotus-miner/Dockerfile b/docker/devnet/lotus-miner/Dockerfile
new file mode 100644
index 000000000..4507e492d
--- /dev/null
+++ b/docker/devnet/lotus-miner/Dockerfile
@@ -0,0 +1,32 @@
+ARG LOTUS_TEST_IMAGE=filecoin/lotus-test:latest
+#############################################################################
+FROM ${LOTUS_TEST_IMAGE}
+
+ARG BUILD_VERSION=0.1
+
+LABEL org.opencontainers.image.version=$BUILD_VERSION \
+      org.opencontainers.image.authors="Boost Dev Team" \
+      name="lotus-miner-dev" \
+      maintainer="Boost Dev Team" \
+      vendor="Boost Dev Team" \
+      version=$BUILD_VERSION \
+      release=$BUILD_VERSION \
+      summary="This image is used to host the lotus-miner dev service" \
+      description="This image is used to host the lotus-miner dev service"
+
+EXPOSE 2345
+ENV LOTUS_SKIP_GENESIS_CHECK=_yes_
+ENV GENESIS_PATH=/var/lib/genesis
+ENV SECTOR_SIZE=8388608
+
+VOLUME /var/tmp/filecoin-proof-parameters
+VOLUME /var/lib/genesis
+
+WORKDIR /app
+RUN mkdir -p /app
+
+COPY entrypoint.sh /app
+
+USER root
+
+ENTRYPOINT ["./entrypoint.sh"]
diff --git a/docker/devnet/lotus-miner/Makefile b/docker/devnet/lotus-miner/Makefile
new file mode 100644
index 000000000..74f8bd1ee
--- /dev/null
+++ b/docker/devnet/lotus-miner/Makefile
@@ -0,0 +1,16 @@
+#####################################################################################
+service=$(docker_user)/lotus-miner-dev
+version?=$(lotus_version)
+########### DOCKER ##################################################################
+tag=$(service):$(version)
+dbuild: 
+	docker build -t $(tag) --build-arg LOTUS_TEST_IMAGE=$(lotus_test_image) --build-arg BUILD_VERSION=$(version) .
+
+dpush: dbuild
+	docker push $(tag)
+
+dscan: dbuild
+	docker scan --accept-license $(tag)		
+#####################################################################################
+.PHONY:
+	dbuild dpush dscan
diff --git a/docker/devnet/lotus-miner/entrypoint.sh b/docker/devnet/lotus-miner/entrypoint.sh
new file mode 100755
index 000000000..e1041ebaa
--- /dev/null
+++ b/docker/devnet/lotus-miner/entrypoint.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -e
+echo Wait for lotus is ready ...
+lotus wait-api
+echo Lotus ready. Lets go
+if [ ! -f $LOTUS_MINER_PATH/.init.miner ]; then
+	echo Import the genesis miner key ...
+	lotus wallet import --as-default $GENESIS_PATH/pre-seal-t01000.key
+	echo Set up the genesis miner ...
+	lotus-miner init --genesis-miner --actor=t01000 --sector-size=$SECTOR_SIZE --pre-sealed-sectors=$GENESIS_PATH --pre-sealed-metadata=$GENESIS_PATH/pre-seal-t01000.json --nosync
+	touch $LOTUS_MINER_PATH/.init.miner
+	echo Done
+fi
+
+echo Starting lotus miner ...
+exec lotus-miner run --nosync
diff --git a/docker/devnet/lotus/Dockerfile b/docker/devnet/lotus/Dockerfile
new file mode 100644
index 000000000..94fc9037d
--- /dev/null
+++ b/docker/devnet/lotus/Dockerfile
@@ -0,0 +1,32 @@
+ARG LOTUS_TEST_IMAGE=filecoin/lotus-test:latest
+#############################################################################
+FROM ${LOTUS_TEST_IMAGE}
+
+ARG BUILD_VERSION=0.1
+
+LABEL org.opencontainers.image.version=$BUILD_VERSION \
+      org.opencontainers.image.authors="Boost Dev Team" \
+      name="lotus-dev" \
+      maintainer="Boost Dev Team" \
+      vendor="Boost Dev Team" \
+      version=$BUILD_VERSION \
+      release=$BUILD_VERSION \
+      summary="This image is used to host the lotus dev service" \
+      description="This image is used to host the lotus dev service"
+
+EXPOSE 1234 
+ENV LOTUS_SKIP_GENESIS_CHECK=_yes_
+ENV GENESIS_PATH=/var/lib/genesis
+ENV SECTOR_SIZE=8388608
+
+VOLUME /var/tmp/filecoin-proof-parameters
+VOLUME /var/lib/genesis
+
+WORKDIR /app
+RUN mkdir -p /app
+
+COPY entrypoint.sh /app
+
+USER root
+
+ENTRYPOINT ["./entrypoint.sh"]
diff --git a/docker/devnet/lotus/Makefile b/docker/devnet/lotus/Makefile
new file mode 100644
index 000000000..8ac9eb49a
--- /dev/null
+++ b/docker/devnet/lotus/Makefile
@@ -0,0 +1,16 @@
+#####################################################################################
+service=$(docker_user)/lotus-dev
+version?=$(lotus_version)
+########### DOCKER ##################################################################
+tag=$(service):$(version)
+dbuild: 
+	docker build -t $(tag) --build-arg LOTUS_TEST_IMAGE=$(lotus_test_image) --build-arg BUILD_VERSION=$(version) .
+
+dpush: dbuild
+	docker push $(tag)
+
+dscan: dbuild
+	docker scan --accept-license $(tag)		
+#####################################################################################
+.PHONY:
+	dbuild dpush dscan
diff --git a/docker/devnet/lotus/entrypoint.sh b/docker/devnet/lotus/entrypoint.sh
new file mode 100755
index 000000000..8c2552275
--- /dev/null
+++ b/docker/devnet/lotus/entrypoint.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -e
+if [ ! -f $LOTUS_PATH/.init.params ]; then
+	echo Initializing fetch params ...
+	lotus fetch-params $SECTOR_SIZE
+	touch $LOTUS_PATH/.init.params
+	echo Done
+fi
+
+if [ ! -f $LOTUS_PATH/.init.genesis ]; then
+	echo Initializing pre seal ...
+	lotus-seed --sector-dir $GENESIS_PATH pre-seal --sector-size $SECTOR_SIZE --num-sectors 1
+	echo Initializing genesis ...
+	lotus-seed --sector-dir $GENESIS_PATH genesis new $LOTUS_PATH/localnet.json
+	echo Initializing address ...
+	lotus-seed --sector-dir $GENESIS_PATH genesis add-miner $LOTUS_PATH/localnet.json $GENESIS_PATH/pre-seal-t01000.json
+	touch $LOTUS_PATH/.init.genesis
+	echo Done
+fi
+
+echo Starting lotus deamon ...
+exec lotus daemon --lotus-make-genesis=$LOTUS_PATH/devgen.car --genesis-template=$LOTUS_PATH/localnet.json --bootstrap=false
diff --git a/docker/monitoring/.gitignore b/docker/monitoring/.gitignore
new file mode 100644
index 000000000..1aed7719e
--- /dev/null
+++ b/docker/monitoring/.gitignore
@@ -0,0 +1 @@
+tempo-data
diff --git a/docker/monitoring/docker-compose.yaml b/docker/monitoring/docker-compose.yaml
new file mode 100644
index 000000000..75dff22e0
--- /dev/null
+++ b/docker/monitoring/docker-compose.yaml
@@ -0,0 +1,67 @@
+version: "3.8"
+
+networks:
+  default:
+    name: monitoring
+
+services:
+  tempo:
+    container_name: tempo
+    image: grafana/tempo:latest
+    command: [ "-search.enabled=true", "-config.file=/etc/tempo.yaml" ]
+    volumes:
+      - ./tempo-local.yaml:/etc/tempo.yaml
+      - ./overrides.yaml:/etc/overrides.yaml
+      - ./tempo-data:/tmp/tempo
+    ports:
+      - "14268:14268"  # jaeger ingest
+    logging:
+      driver: loki
+      options:
+        loki-url: 'http://localhost:3100/loki/api/v1/push'
+
+  loki:
+    container_name: loki
+    image: grafana/loki:2.3.0
+    command: [ "-config.file=/etc/loki/local-config.yaml" ]
+    ports:
+      - "3100:3100"                                   # loki needs to be exposed so it receives logs
+    environment:
+      - JAEGER_AGENT_HOST=tempo
+      - JAEGER_ENDPOINT=http://tempo:14268/api/traces # send traces to Tempo
+      - JAEGER_SAMPLER_TYPE=const
+      - JAEGER_SAMPLER_PARAM=1
+    logging:
+      driver: loki
+      options:
+        loki-url: 'http://localhost:3100/loki/api/v1/push'
+
+  prometheus:
+    container_name: prometheus
+    image: prom/prometheus:latest
+    command: [ "--config.file=/etc/prometheus.yaml" ]
+    volumes:
+      - ./prometheus.yaml:/etc/prometheus.yaml
+    ports:
+      - "9090:9090"
+    logging:
+      driver: loki
+      options:
+        loki-url: 'http://localhost:3100/loki/api/v1/push'
+
+  grafana:
+    container_name: grafana
+    image: grafana/grafana:main
+    volumes:
+      - ./grafana.ini:/etc/grafana/grafana.ini
+      - ./grafana-datasources.yaml:/etc/grafana/provisioning/datasources/datasources.yaml
+    #environment:
+      #- GF_AUTH_ANONYMOUS_ENABLED=true
+      #- GF_AUTH_ANONYMOUS_ORG_ROLE=Admin
+      #- GF_AUTH_DISABLE_LOGIN_FORM=true
+    ports:
+      - "3333:3000"
+    logging:
+      driver: loki
+      options:
+        loki-url: 'http://localhost:3100/loki/api/v1/push'
diff --git a/docker/monitoring/grafana-datasources.yaml b/docker/monitoring/grafana-datasources.yaml
new file mode 100644
index 000000000..1a34fc7ea
--- /dev/null
+++ b/docker/monitoring/grafana-datasources.yaml
@@ -0,0 +1,39 @@
+apiVersion: 1
+
+datasources:
+- name: Prometheus
+  type: prometheus
+  access: proxy
+  orgId: 1
+  url: http://prometheus:9090
+  basicAuth: false
+  isDefault: false
+  version: 1
+  editable: false
+- name: Tempo
+  type: tempo
+  access: proxy
+  orgId: 1
+  url: http://tempo:3200
+  basicAuth: false
+  isDefault: true
+  version: 1
+  editable: false
+  apiVersion: 1
+  uid: tempo
+- name: Loki
+  type: loki
+  access: proxy
+  orgId: 1
+  url: http://loki:3100
+  basicAuth: false
+  isDefault: false
+  version: 1
+  editable: false
+  apiVersion: 1
+  jsonData:
+    derivedFields:
+      - datasourceUid: tempo
+        matcherRegex: (?:traceID|trace_id)=(\w+)
+        name: TraceID
+        url: $${__value.raw}
\ No newline at end of file
diff --git a/docker/monitoring/grafana.ini b/docker/monitoring/grafana.ini
new file mode 100644
index 000000000..8da2d7db4
--- /dev/null
+++ b/docker/monitoring/grafana.ini
@@ -0,0 +1,3 @@
+[feature_toggles]
+enable = tempoSearch tempoBackendSearch
+
diff --git a/docker/monitoring/overrides.yaml b/docker/monitoring/overrides.yaml
new file mode 100644
index 000000000..a07dcff49
--- /dev/null
+++ b/docker/monitoring/overrides.yaml
@@ -0,0 +1,14 @@
+overrides:
+  "single-tenant":
+    search_tags_allow_list:
+      - "instance"
+    ingestion_rate_strategy: "local"
+    ingestion_rate_limit_bytes: 15000000
+    ingestion_burst_size_bytes: 20000000
+    max_traces_per_user: 10000
+    max_global_traces_per_user: 0
+    max_bytes_per_trace: 50000
+    max_search_bytes_per_trace: 0
+    max_bytes_per_tag_values_query: 5000000
+    block_retention: 0s
+
diff --git a/docker/monitoring/prometheus.yaml b/docker/monitoring/prometheus.yaml
new file mode 100644
index 000000000..2ac68598a
--- /dev/null
+++ b/docker/monitoring/prometheus.yaml
@@ -0,0 +1,11 @@
+global:
+  scrape_interval:     15s
+  evaluation_interval: 15s
+
+scrape_configs:
+  - job_name: 'prometheus'
+    static_configs:
+      - targets: [ 'localhost:9090' ]
+  - job_name: 'tempo'
+    static_configs:
+      - targets: [ 'tempo:3200' ]
\ No newline at end of file
diff --git a/docker/monitoring/tempo-local.yaml b/docker/monitoring/tempo-local.yaml
new file mode 100644
index 000000000..3abc9c2a5
--- /dev/null
+++ b/docker/monitoring/tempo-local.yaml
@@ -0,0 +1,65 @@
+metrics_generator_enabled: true
+
+server:
+  http_listen_port: 3200
+
+distributor:
+  search_tags_deny_list:
+    - "instance"
+    - "version"
+  receivers:                           # this configuration will listen on all ports and protocols that tempo is capable of.
+    jaeger:                            # the receives all come from the OpenTelemetry collector.  more configuration information can
+      protocols:                       # be found there: https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver
+        thrift_http:                   #
+        grpc:                          # for a production deployment you should only enable the receivers you need!
+        thrift_binary:
+        thrift_compact:
+    zipkin:
+    otlp:
+      protocols:
+        http:
+        grpc:
+    opencensus:
+
+ingester:
+  trace_idle_period: 10s               # the length of time after a trace has not received spans to consider it complete and flush it
+  max_block_bytes: 1_000_000           # cut the head block when it hits this size or ...
+  max_block_duration: 5m               #   this much time passes
+
+compactor:
+  compaction:
+    compaction_window: 1h              # blocks in this time window will be compacted together
+    max_block_bytes: 100_000_000       # maximum size of compacted blocks
+    block_retention: 1h
+    compacted_block_retention: 10m
+
+metrics_generator:
+  registry:
+    external_labels:
+      source: tempo
+      cluster: docker-compose
+  storage:
+    path: /tmp/tempo/generator/wal
+    remote_write:
+      - url: http://prometheus:9090/api/v1/write
+        send_exemplars: true
+
+storage:
+  trace:
+    backend: local                     # backend configuration to use
+    block:
+      bloom_filter_false_positive: .05 # bloom filter false positive rate.  lower values create larger filters but fewer false positives
+      index_downsample_bytes: 1000     # number of bytes per index record
+      encoding: zstd                   # block encoding/compression.  options: none, gzip, lz4-64k, lz4-256k, lz4-1M, lz4, snappy, zstd, s2
+    wal:
+      path: /tmp/tempo/wal             # where to store the the wal locally
+      encoding: snappy                 # wal encoding/compression.  options: none, gzip, lz4-64k, lz4-256k, lz4-1M, lz4, snappy, zstd, s2
+    local:
+      path: /tmp/tempo/blocks
+    pool:
+      max_workers: 100                 # worker pool determines the number of parallel requests to the object store backend
+      queue_depth: 10000
+
+overrides:
+  per_tenant_override_config: /etc/overrides.yaml
+  metrics_generator_processors: [service-graphs, span-metrics]
diff --git a/documentation/devnet.md b/documentation/devnet.md
deleted file mode 100644
index aedea9424..000000000
--- a/documentation/devnet.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# Devnet
-
-To run Boost on your development machine, you will need to set up a devnet:
-
-1. Remove any existing lotus repo and boost repo
-```
-rm -rf ~/.lotusmarkets && rm -rf ~/.lotus && rm -rf ~/.lotusminer && rm -rf ~/.genesis_sectors
-rm -rf ~/.boost
-```
-
-2. Build lotus in debug mode
-
-The version of lotus needs to match the version in boost's go.mod
-```
-cd lotus
-git checkout <tag>
-make debug
-```
-
-3. Install lotus
-
-The devnet script uses the installed lotus to run the miner and daemon.
-```
-make install
-install -C ./lotus-seed /usr/local/bin/lotus-seed
-```
-
-4. Build boost in debug mode
-
-Double check if environment variables are set:
-```
-export LIBRARY_PATH=/opt/homebrew/lib
-export PATH="$(brew --prefix coreutils)/libexec/gnubin:/usr/local/bin:$PATH"
-```
-
-Build & Install
-```
-cd boost
-make debug
-make install
-```
-
-3. Start the devnet
-
-The following command will use the lotus binaries that you built and installed above, and especially it will run `lotus`, `lotus-miner` and `lotus-seed`. So the lotus version must match the version in boost's go.mod.
-```
-cd boost
-./devnet
-```
-
-The first time you run it, it will install a lot of metadata-related proofs. It will take at least 30 minutes depending on your connection speed. You may need to restart the command multiple times as your terminal will probably timeout before it finishes downloading everything.
-
-You can also use `./devnet &` instead of `./devnet` to run the process in the background - that would prevent you from having to manually restart the command when your terminal times out.
-
-NOTE: 
-The devnet isn't designed to be restartable unfortunately. After it has been successfully run once, you'll have to clear out the previous data before re-running `./devnet`: 
-```
-rm -rf ~/.lotusmarkets && rm -rf ~/.lotus && rm -rf ~/.lotusminer && rm -rf ~/.genesis_sectors
-```
-
-4. Wait for lotus-miner to come up (through the command above)
-
-Unset these variables as they interfere with the `lotus-miner` command.
-```
-unset MINER_API_INFO
-unset FULLNODE_API_INFO
-```
-Then repeatedly run this command until it succeeds:
-```
-lotus-miner auth api-info --perm=admin
-```
-
-5. Get the auth tokens to connect to the lotus daemon and miner:
-```
-export ENV_MINER_API_INFO=`lotus-miner auth api-info --perm=admin`
-export ENV_FULLNODE_API_INFO=`lotus auth api-info --perm=admin`
-
-export MINER_API_INFO=`echo $ENV_MINER_API_INFO | awk '{split($0,a,"="); print a[2]}'`
-export FULLNODE_API_INFO=`echo $ENV_FULLNODE_API_INFO | awk '{split($0,a,"="); print a[2]}'`
-
-echo MINER_API_INFO=$MINER_API_INFO
-echo FULLNODE_API_INFO=$FULLNODE_API_INFO
-```
-
-6. Create the wallets needed for boost
-```
-export DEFAULT_WALLET=`lotus wallet list | tail -1 | awk '{print $1}'`
-export COLLAT_WALLET=`lotus wallet new bls`
-export PUBMSG_WALLET=`lotus wallet new bls`
-export CLIENT_WALLET=`lotus wallet new bls`
-```
-
-7. Add funds to the wallets
-```
-lotus send --from $DEFAULT_WALLET $COLLAT_WALLET 10
-lotus send --from $DEFAULT_WALLET $PUBMSG_WALLET 10
-lotus send --from $DEFAULT_WALLET $CLIENT_WALLET 10
-```
-
-Run this command repeatedly until each wallet you created has 10 FIL:
-```
-lotus wallet list
-```
-This should take about 10 seconds.
-
-8. Set the Publish Message Wallet as a control address on the miner
-```
-lotus-miner actor control set --really-do-it $PUBMSG_WALLET
-```
-
-9. Add funds into the Market Actor escrow for the client and Collateral wallets
-```
-lotus wallet market add --from $DEFAULT_WALLET --address $CLIENT_WALLET 5
-lotus wallet market add --address $COLLAT_WALLET 5
-```
-
-10. Initialize boost
-```
-boostd -vv init \
-  --api-sealer=$MINER_API_INFO \
-  --api-sector-index=$MINER_API_INFO \
-  --wallet-publish-storage-deals=$PUBMSG_WALLET \
-  --wallet-deal-collateral=$COLLAT_WALLET \
-  --max-staging-deals-bytes=2000000000
-```
-
-11. Build the Web UI
-```
-make react
-```
-
-12. Edit config to set a fixed listen address
-
-Open `~/.boost/config.toml`
-
-Set the port in the `ListenAddresses` key to `50000` 
-```
-[Libp2p]
-  ListenAddresses = ["/ip4/0.0.0.0/tcp/50000", "/ip6/::/tcp/0"]
-```
-
-13. Run boost
-```
-boostd -vv run
-```
-
-Note down the peer ID of the boost instance:
-```
-2022-06-10T09:32:28.819Z        INFO    boostd  boostd/run.go:114       Boost libp2p node listening     {"maddr": "{12D3KooWQNNWNiJ1mieEk9EHjDVF2qBc1FSjJGEzwjnMJzteApaW: [/ip4/172.17.0.2/tcp/50000 /ip4/127.0.0.1/tcp/50000]}"}
-```
-In this example: `12D3KooWQNNWNiJ1mieEk9EHjDVF2qBc1FSjJGEzwjnMJzteApaW`
-
-14. Set the peer ID and multi-address of the miner on chain
-```
-lotus-miner actor set-peer-id <peer id>
-lotus-miner actor set-addrs /ip4/127.0.0.1/tcp/50000
-```
-
-15. Open the Web UI
-
-Open http://localhost:8080 to see the Boost UI
-
-## Make a deal with Boost
-
-2. Initialize the boost client
-```
-boost init
-```
-
-This will output the address of the wallet (it's safe to run the init command repeatedly).
-
-2. Send funds to the client wallet
-```
-lotus send --from=$DEFAULT_WALLET <client wallet> 10
-```
-
-3. Follow the guide at https://boost.filecoin.io/tutorials/how-to-store-files-with-boost-on-filecoin
-
-Note that above you already ran a command to export FULLNODE_API (and point it to your local devnet lotus daemon).
-
-Note also that the provider address is `t01000` and you will need to supply an appropriate `--storage-price` when using `boost deal` since the devnet has a minimum price. Alternatively, using "Settings" in the Boost web UI to set the deal price to zero. 
diff --git a/go.mod b/go.mod
index 53fe09eed..47023beb6 100644
--- a/go.mod
+++ b/go.mod
@@ -98,11 +98,19 @@ require (
 	github.com/whyrusleeping/base32 v0.0.0-20170828182744-c30ac30633cc
 	github.com/whyrusleeping/cbor-gen v0.0.0-20220323183124-98fa8256a799
 	go.opencensus.io v0.23.0
+	go.opentelemetry.io/otel v1.9.0
+	go.opentelemetry.io/otel/bridge/opencensus v0.31.0
+	go.opentelemetry.io/otel/exporters/jaeger v1.2.0
+	go.opentelemetry.io/otel/sdk v1.9.0
+	go.opentelemetry.io/otel/trace v1.9.0
 	go.uber.org/atomic v1.9.0
 	go.uber.org/fx v1.15.0
 	go.uber.org/multierr v1.8.0
+	golang.org/x/exp v0.0.0-20220426173459-3bcf042a4bf5
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	golang.org/x/tools v0.1.11
 	golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f
+	google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1 // indirect
+	google.golang.org/grpc v1.46.2 // indirect
 	gopkg.in/cheggaaa/pb.v1 v1.0.28
 )
diff --git a/go.sum b/go.sum
index 24e7fffea..a2b8bebe3 100644
--- a/go.sum
+++ b/go.sum
@@ -215,6 +215,7 @@ github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XP
 github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
 github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
@@ -334,6 +335,7 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
 github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
+github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/etclabscore/go-jsonschema-walk v0.0.6 h1:DrNzoKWKd8f8XB5nFGBY00IcjakRE22OTI12k+2LkyY=
 github.com/etclabscore/go-jsonschema-walk v0.0.6/go.mod h1:VdfDY72AFAiUhy0ZXEaWSpveGjMT5JcDIm903NGqFwQ=
@@ -2066,6 +2068,7 @@ github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5J
 github.com/streadway/handy v0.0.0-20200128134331-0f66f006fb2e/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0 h1:M2gUjqZET1qApGOWNSnZ49BAIMX4F/1plDv3+l31EJ4=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
@@ -2230,24 +2233,37 @@ go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
 go.opentelemetry.io/otel v0.20.0/go.mod h1:Y3ugLH2oa81t5QO+Lty+zXf8zC9L26ax4Nzoxm/dooo=
 go.opentelemetry.io/otel v1.2.0/go.mod h1:aT17Fk0Z1Nor9e0uisf98LrntPGMnk4frBO9+dkf69I=
 go.opentelemetry.io/otel v1.3.0/go.mod h1:PWIKzi6JCp7sM0k9yZ43VX+T345uNbAkDKwHVjb2PTs=
-go.opentelemetry.io/otel v1.7.0 h1:Z2lA3Tdch0iDcrhJXDIlC94XE+bxok1F9B+4Lz/lGsM=
 go.opentelemetry.io/otel v1.7.0/go.mod h1:5BdUoMIz5WEs0vt0CUEMtSSaTSHBBVwrhnz7+nrD5xk=
+go.opentelemetry.io/otel v1.8.0/go.mod h1:2pkj+iMj0o03Y+cW6/m8Y4WkRdYN3AvCXCnzRMp9yvM=
+go.opentelemetry.io/otel v1.9.0 h1:8WZNQFIB2a71LnANS9JeyidJKKGOOremcUtb/OtHISw=
+go.opentelemetry.io/otel v1.9.0/go.mod h1:np4EoPGzoPs3O67xUVNoPPcmSvsfOxNlNA4F4AC+0Eo=
 go.opentelemetry.io/otel/bridge/opencensus v0.25.0/go.mod h1:dkZDdaNwLlIutxK2Kc2m3jwW2M1ISaNf8/rOYVwuVHs=
+go.opentelemetry.io/otel/bridge/opencensus v0.31.0 h1:8Wk5/hHtEdTpYwUz0Ny8I+ccqfIMbp8Ce8/ZXlN4WPc=
+go.opentelemetry.io/otel/bridge/opencensus v0.31.0/go.mod h1:hgI/HZyVIo3QL0RBmlOy2/VIQCc27OC1c/4ifwqTv4A=
+go.opentelemetry.io/otel/exporters/jaeger v1.2.0 h1:C/5Egj3MJBXRJi22cSl07suqPqtZLnLFmH//OxETUEc=
 go.opentelemetry.io/otel/exporters/jaeger v1.2.0/go.mod h1:KJLFbEMKTNPIfOxcg/WikIozEoKcPgJRz3Ce1vLlM8E=
 go.opentelemetry.io/otel/internal/metric v0.25.0/go.mod h1:Nhuw26QSX7d6n4duoqAFi5KOQR4AuzyMcl5eXOgwxtc=
 go.opentelemetry.io/otel/metric v0.20.0/go.mod h1:598I5tYlH1vzBjn+BTuhzTCSb/9debfNp6R3s7Pr1eU=
 go.opentelemetry.io/otel/metric v0.25.0/go.mod h1:E884FSpQfnJOMMUaq+05IWlJ4rjZpk2s/F1Ju+TEEm8=
+go.opentelemetry.io/otel/metric v0.31.0 h1:6SiklT+gfWAwWUR0meEMxQBtihpiEs4c+vL9spDTqUs=
+go.opentelemetry.io/otel/metric v0.31.0/go.mod h1:ohmwj9KTSIeBnDBm/ZwH2PSZxZzoOaG2xZeekTRzL5A=
 go.opentelemetry.io/otel/oteltest v0.20.0/go.mod h1:L7bgKf9ZB7qCwT9Up7i9/pn0PWIa9FqQ2IQ8LoxiGnw=
 go.opentelemetry.io/otel/sdk v0.20.0/go.mod h1:g/IcepuwNsoiX5Byy2nNV0ySUF1em498m7hBWC279Yc=
-go.opentelemetry.io/otel/sdk v1.2.0 h1:wKN260u4DesJYhyjxDa7LRFkuhH7ncEVKU37LWcyNIo=
 go.opentelemetry.io/otel/sdk v1.2.0/go.mod h1:jNN8QtpvbsKhgaC6V5lHiejMoKD+V8uadoSafgHPx1U=
+go.opentelemetry.io/otel/sdk v1.8.0/go.mod h1:uPSfc+yfDH2StDM/Rm35WE8gXSNdvCg023J6HeGNO0c=
+go.opentelemetry.io/otel/sdk v1.9.0 h1:LNXp1vrr83fNXTHgU8eO89mhzxb/bbWAsHG6fNf3qWo=
+go.opentelemetry.io/otel/sdk v1.9.0/go.mod h1:AEZc8nt5bd2F7BC24J5R0mrjYnpEgYHyTcM/vrSple4=
 go.opentelemetry.io/otel/sdk/export/metric v0.25.0/go.mod h1:Ej7NOa+WpN49EIcr1HMUYRvxXXCCnQCg2+ovdt2z8Pk=
 go.opentelemetry.io/otel/sdk/metric v0.25.0/go.mod h1:G4xzj4LvC6xDDSsVXpvRVclQCbofGGg4ZU2VKKtDRfg=
+go.opentelemetry.io/otel/sdk/metric v0.31.0 h1:2sZx4R43ZMhJdteKAlKoHvRgrMp53V1aRxvEf5lCq8Q=
+go.opentelemetry.io/otel/sdk/metric v0.31.0/go.mod h1:fl0SmNnX9mN9xgU6OLYLMBMrNAsaZQi7qBwprwO3abk=
 go.opentelemetry.io/otel/trace v0.20.0/go.mod h1:6GjCW8zgDjwGHGa6GkyeB8+/5vjT16gUEi0Nf1iBdgw=
 go.opentelemetry.io/otel/trace v1.2.0/go.mod h1:N5FLswTubnxKxOJHM7XZC074qpeEdLy3CgAVsdMucK0=
 go.opentelemetry.io/otel/trace v1.3.0/go.mod h1:c/VDhno8888bvQYmbYLqe41/Ldmr/KKunbvWM4/fEjk=
-go.opentelemetry.io/otel/trace v1.7.0 h1:O37Iogk1lEkMRXewVtZ1BBTVn5JEp8GrJvP92bJqC6o=
 go.opentelemetry.io/otel/trace v1.7.0/go.mod h1:fzLSB9nqR2eXzxPXb2JW9IKE+ScyXA48yyE4TNvoHqU=
+go.opentelemetry.io/otel/trace v1.8.0/go.mod h1:0Bt3PXY8w+3pheS3hQUt+wow8b1ojPaTBoTCh2zIFI4=
+go.opentelemetry.io/otel/trace v1.9.0 h1:oZaCNJUjWcg60VXWee8lJKlqhPbXAPB51URuR47pQYc=
+go.opentelemetry.io/otel/trace v1.9.0/go.mod h1:2737Q0MuG8q1uILYm2YYVkAyLtOofiTNGg6VODnOiPo=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
@@ -2784,8 +2800,9 @@ google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6D
 google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
-google.golang.org/genproto v0.0.0-20210917145530-b395a37504d4 h1:ysnBoUyeL/H6RCvNRhWHjKoDEmguI+mPU+qHgK8qv/w=
 google.golang.org/genproto v0.0.0-20210917145530-b395a37504d4/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
+google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1 h1:b9mVrqYfq3P4bCdaLg1qtBnPzUYgglsIdjZkL/fQVOE=
+google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
@@ -2813,8 +2830,9 @@ google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv
 google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
 google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
 google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.45.0 h1:NEpgUqV3Z+ZjkqMsxMg11IaDrXY4RY6CQukSGK0uI1M=
 google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
+google.golang.org/grpc v1.46.2 h1:u+MLGgVf7vRdjEYZ8wDFhAVNmhkbJ5hmrA1LMWK1CAQ=
+google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
diff --git a/gql/resolver.go b/gql/resolver.go
index 4884fda73..2cabdbbec 100644
--- a/gql/resolver.go
+++ b/gql/resolver.go
@@ -102,7 +102,7 @@ func (r *resolver) Deal(ctx context.Context, args struct{ ID graphql.ID }) (*dea
 		return nil, err
 	}
 
-	return newDealResolver(deal, r.dealsDB, r.logsDB, r.spApi), nil
+	return newDealResolver(deal, r.provider, r.dealsDB, r.logsDB, r.spApi), nil
 }
 
 type dealsArgs struct {
@@ -135,7 +135,7 @@ func (r *resolver) Deals(ctx context.Context, args dealsArgs) (*dealListResolver
 
 	resolvers := make([]*dealResolver, 0, len(deals))
 	for _, deal := range deals {
-		resolvers = append(resolvers, newDealResolver(&deal, r.dealsDB, r.logsDB, r.spApi))
+		resolvers = append(resolvers, newDealResolver(&deal, r.provider, r.dealsDB, r.logsDB, r.spApi))
 	}
 
 	return &dealListResolver{
@@ -168,7 +168,7 @@ func (r *resolver) DealUpdate(ctx context.Context, args struct{ ID graphql.ID })
 	}
 
 	net := make(chan *dealResolver, 1)
-	net <- newDealResolver(deal, r.dealsDB, r.logsDB, r.spApi)
+	net <- newDealResolver(deal, r.provider, r.dealsDB, r.logsDB, r.spApi)
 
 	// Updates to deal state are broadcast on pubsub. Pipe these updates to the
 	// client
@@ -180,7 +180,7 @@ func (r *resolver) DealUpdate(ctx context.Context, args struct{ ID graphql.ID })
 		}
 		return nil, fmt.Errorf("%s: subscribing to deal updates: %w", args.ID, err)
 	}
-	sub := &subLastUpdate{sub: dealUpdatesSub, dealsDB: r.dealsDB, logsDB: r.logsDB, spApi: r.spApi}
+	sub := &subLastUpdate{sub: dealUpdatesSub, provider: r.provider, dealsDB: r.dealsDB, logsDB: r.logsDB, spApi: r.spApi}
 	go func() {
 		sub.Pipe(ctx, net) // blocks until connection is closed
 		close(net)
@@ -219,7 +219,7 @@ func (r *resolver) DealNew(ctx context.Context) (<-chan *dealNewResolver, error)
 			case evti := <-sub.Out():
 				// Pipe the deal to the new deal channel
 				di := evti.(types.ProviderDealState)
-				rsv := newDealResolver(&di, r.dealsDB, r.logsDB, r.spApi)
+				rsv := newDealResolver(&di, r.provider, r.dealsDB, r.logsDB, r.spApi)
 				totalCount, err := r.dealsDB.Count(ctx, "")
 				if err != nil {
 					log.Errorf("getting total deal count: %w", err)
@@ -330,15 +330,17 @@ func (r *resolver) dealList(ctx context.Context, query string, cursor *graphql.I
 
 type dealResolver struct {
 	types.ProviderDealState
+	provider    *storagemarket.Provider
 	transferred uint64
 	dealsDB     *db.DealsDB
 	logsDB      *db.LogsDB
 	spApi       sealingpipeline.API
 }
 
-func newDealResolver(deal *types.ProviderDealState, dealsDB *db.DealsDB, logsDB *db.LogsDB, spApi sealingpipeline.API) *dealResolver {
+func newDealResolver(deal *types.ProviderDealState, provider *storagemarket.Provider, dealsDB *db.DealsDB, logsDB *db.LogsDB, spApi sealingpipeline.API) *dealResolver {
 	return &dealResolver{
 		ProviderDealState: *deal,
+		provider:          provider,
 		transferred:       uint64(deal.NBytesReceived),
 		dealsDB:           dealsDB,
 		logsDB:            logsDB,
@@ -502,13 +504,17 @@ func (dr *dealResolver) message(ctx context.Context, checkpoint dealcheckpoints.
 		if dr.IsOffline {
 			return "Awaiting Offline Data Import"
 		}
-		switch dr.transferred {
-		case 0:
+		switch {
+		case dr.transferred == 0 && !dr.provider.IsTransferStalled(dr.DealUuid):
 			return "Transfer Queued"
-		case 100:
+		case dr.transferred == 100:
 			return "Transfer Complete"
 		default:
 			pct := (100 * dr.transferred) / dr.ProviderDealState.Transfer.Size
+			isStalled := dr.provider.IsTransferStalled(dr.DealUuid)
+			if isStalled {
+				return fmt.Sprintf("Transfer stalled at %d%% ", pct)
+			}
 			return fmt.Sprintf("Transferring %d%%", pct)
 		}
 	case dealcheckpoints.Transferred:
@@ -533,6 +539,22 @@ func (dr *dealResolver) message(ctx context.Context, checkpoint dealcheckpoints.
 	return checkpoint.String()
 }
 
+func (dr *dealResolver) TransferSamples() []*transferPoint {
+	points := dr.provider.Transfer(dr.DealUuid)
+	pts := make([]*transferPoint, 0, len(points))
+	for _, pt := range points {
+		pts = append(pts, &transferPoint{
+			At:    graphql.Time{Time: pt.At},
+			Bytes: gqltypes.Uint64(pt.Bytes),
+		})
+	}
+	return pts
+}
+
+func (dr *dealResolver) IsTransferStalled() bool {
+	return dr.provider.IsTransferStalled(dr.DealUuid)
+}
+
 func (dr *dealResolver) sealingState(ctx context.Context) string {
 	si, err := dr.spApi.SectorsStatus(ctx, dr.SectorID, false)
 	if err != nil {
@@ -594,10 +616,11 @@ func toUuid(id graphql.ID) (uuid.UUID, error) {
 }
 
 type subLastUpdate struct {
-	sub     event.Subscription
-	dealsDB *db.DealsDB
-	logsDB  *db.LogsDB
-	spApi   sealingpipeline.API
+	sub      event.Subscription
+	provider *storagemarket.Provider
+	dealsDB  *db.DealsDB
+	logsDB   *db.LogsDB
+	spApi    sealingpipeline.API
 }
 
 func (s *subLastUpdate) Pipe(ctx context.Context, net chan *dealResolver) {
@@ -636,7 +659,7 @@ func (s *subLastUpdate) Pipe(ctx context.Context, net chan *dealResolver) {
 	loop:
 		for {
 			di := lastUpdate.(types.ProviderDealState)
-			rsv := newDealResolver(&di, s.dealsDB, s.logsDB, s.spApi)
+			rsv := newDealResolver(&di, s.provider, s.dealsDB, s.logsDB, s.spApi)
 
 			select {
 			case <-ctx.Done():
diff --git a/gql/resolver_transfers.go b/gql/resolver_transfers.go
index a4c7091a3..e7a20f306 100644
--- a/gql/resolver_transfers.go
+++ b/gql/resolver_transfers.go
@@ -6,6 +6,8 @@ import (
 	"time"
 
 	gqltypes "github.com/filecoin-project/boost/gql/types"
+	"github.com/filecoin-project/boost/storagemarket"
+	"github.com/google/uuid"
 	"github.com/graph-gophers/graphql-go"
 )
 
@@ -15,15 +17,62 @@ type transferPoint struct {
 }
 
 // query: transfers: [TransferPoint]
-func (r *resolver) Transfers(_ context.Context) ([]*transferPoint, error) {
-	deals := r.provider.Transfers()
+func (r *resolver) Transfers(_ context.Context) []*transferPoint {
+	return r.getTransferSamples(r.provider.Transfers(), nil)
+}
+
+type transferStats struct {
+	HttpMaxConcurrentDownloads int32
+	Stats                      []*hostTransferStats
+}
+
+type hostTransferStats struct {
+	Host            string
+	Total           int32
+	Started         int32
+	Stalled         int32
+	TransferSamples []*transferPoint
+}
+
+// query: transferStats: TransferStats
+func (r *resolver) TransferStats(_ context.Context) *transferStats {
+	transfersByDeal := r.provider.Transfers()
+	stats := r.provider.TransferStats()
+	gqlStats := make([]*hostTransferStats, 0, len(stats))
+	for _, s := range stats {
+		gqlStats = append(gqlStats, &hostTransferStats{
+			Host:            s.Host,
+			Total:           int32(s.Total),
+			Started:         int32(s.Started),
+			Stalled:         int32(s.Stalled),
+			TransferSamples: r.getTransferSamples(transfersByDeal, s.DealUuids),
+		})
+	}
+	return &transferStats{
+		HttpMaxConcurrentDownloads: int32(r.cfg.Dealmaking.HttpTransferMaxConcurrentDownloads),
+		Stats:                      gqlStats,
+	}
+}
+
+func (r *resolver) getTransferSamples(deals map[uuid.UUID][]storagemarket.TransferPoint, filter []uuid.UUID) []*transferPoint {
+	// If filter is nil, include all deals
+	if filter == nil {
+		for dealUuid := range deals {
+			filter = append(filter, dealUuid)
+		}
+	}
 
 	// We have
 	// dealUUID -> [At: <time>, Transferred: <bytes>, At: <time>, Transferred: <bytes>, ...]
 	// Convert this to
 	// <time> -> <transferred per second>
 	totalAt := make(map[time.Time]uint64)
-	for _, points := range deals {
+	for _, dealUuid := range filter {
+		points, ok := deals[dealUuid]
+		if !ok {
+			continue
+		}
+
 		var prev uint64
 		first := true
 		for _, pt := range points {
@@ -53,5 +102,5 @@ func (r *resolver) Transfers(_ context.Context) ([]*transferPoint, error) {
 		return pts[i].At.Before(pts[j].At.Time)
 	})
 
-	return pts, nil
+	return pts
 }
diff --git a/gql/schema.graphql b/gql/schema.graphql
index 2be280db6..dec85697e 100644
--- a/gql/schema.graphql
+++ b/gql/schema.graphql
@@ -59,6 +59,8 @@ type Deal {
   PublishCid: String!
   IsOffline: Boolean!
   Transfer: TransferParams!
+  TransferSamples: [TransferPoint]!
+  IsTransferStalled: Boolean!
   Checkpoint: String!
   CheckpointAt: Time!
   Err: String!
@@ -287,6 +289,19 @@ type TransferPoint {
   Bytes: Uint64!
 }
 
+type HostStats {
+  Host: String!
+  Total: Int!
+  Started: Int!
+  Stalled: Int!
+  TransferSamples: [TransferPoint]!
+}
+
+type TransferStats {
+  HttpMaxConcurrentDownloads: Int!
+  Stats: [HostStats]!
+}
+
 type MpoolMessage {
   From: String!
   To: String!
@@ -377,6 +392,9 @@ type RootQuery {
   """Get ongoing transfers"""
   transfers: [TransferPoint]!
 
+  """Get stats about queued / active transfers"""
+  transferStats: TransferStats!
+
   """Get local messages in the mpool"""
   mpool(local: Boolean!): [MpoolMessage]!
 
diff --git a/node/builder.go b/node/builder.go
index c76a44852..7e709ee83 100644
--- a/node/builder.go
+++ b/node/builder.go
@@ -24,6 +24,7 @@ import (
 	"github.com/filecoin-project/boost/storagemarket"
 	"github.com/filecoin-project/boost/storagemarket/dealfilter"
 	smtypes "github.com/filecoin-project/boost/storagemarket/types"
+	"github.com/filecoin-project/boost/tracing"
 	"github.com/filecoin-project/dagstore"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
@@ -463,7 +464,8 @@ func ConfigBoost(cfg *config.Boost) Option {
 		})),
 
 		Override(new(*storagemanager.StorageManager), storagemanager.New(storagemanager.Config{
-			MaxStagingDealsBytes: uint64(cfg.Dealmaking.MaxStagingDealsBytes),
+			MaxStagingDealsBytes:          uint64(cfg.Dealmaking.MaxStagingDealsBytes),
+			MaxStagingDealsPercentPerHost: uint64(cfg.Dealmaking.MaxStagingDealsPercentPerHost),
 		})),
 
 		// Sector API
@@ -484,6 +486,9 @@ func ConfigBoost(cfg *config.Boost) Option {
 		// GraphQL server
 		Override(new(*gql.Server), modules.NewGraphqlServer(cfg)),
 
+		// Tracing
+		Override(new(*tracing.Tracing), modules.NewTracing(cfg)),
+
 		// Address selector
 		Override(new(*ctladdr.AddressSelector), lotus_modules.AddressSelector(&lotus_config.MinerAddressConfig{
 			DealPublishControl: []string{cfg.Wallets.PublishStorageDeals},
diff --git a/node/config/def.go b/node/config/def.go
index 9ae9048fd..2b39f7ba9 100644
--- a/node/config/def.go
+++ b/node/config/def.go
@@ -66,6 +66,12 @@ func DefaultBoost() *Boost {
 			Port: 8080,
 		},
 
+		Tracing: TracingConfig{
+			Enabled:     false,
+			Endpoint:    "",
+			ServiceName: "boostd",
+		},
+
 		Dealmaking: DealmakingConfig{
 			ConsiderOnlineStorageDeals:     true,
 			ConsiderOfflineStorageDeals:    true,
@@ -79,9 +85,6 @@ func DefaultBoost() *Boost {
 			ExpectedSealDuration:            Duration(time.Hour * 24),
 			MaxProviderCollateralMultiplier: 2,
 
-			SimultaneousTransfersForStorage:   DefaultSimultaneousTransfers,
-			SimultaneousTransfersForRetrieval: DefaultSimultaneousTransfers,
-
 			StartEpochSealingBuffer: 480, // 480 epochs buffer == 4 hours from adding deal to sector to sector being sealed
 
 			DealProposalLogDuration: Duration(time.Hour * 24),
@@ -97,7 +100,13 @@ func DefaultBoost() *Boost {
 			},
 
 			MaxTransferDuration: Duration(24 * 3600 * time.Second),
-			RemoteCommp:         false,
+
+			RemoteCommp:             false,
+			MaxConcurrentLocalCommp: 1,
+
+			HttpTransferMaxConcurrentDownloads: 20,
+			HttpTransferStallTimeout:           Duration(5 * time.Minute),
+			HttpTransferStallCheckPeriod:       Duration(30 * time.Second),
 		},
 
 		LotusDealmaking: lotus_config.DealmakingConfig{
diff --git a/node/config/doc_gen.go b/node/config/doc_gen.go
index 30f54ebf2..7f15105e0 100644
--- a/node/config/doc_gen.go
+++ b/node/config/doc_gen.go
@@ -61,6 +61,12 @@ your node if metadata log is disabled`,
 
 			Comment: ``,
 		},
+		{
+			Name: "Tracing",
+			Type: "TracingConfig",
+
+			Comment: ``,
+		},
 		{
 			Name: "LotusDealmaking",
 			Type: "lotus_config.DealmakingConfig",
@@ -180,20 +186,28 @@ as a multiplier of the minimum collateral bound`,
 			Name: "MaxStagingDealsBytes",
 			Type: "int64",
 
-			Comment: `The maximum allowed disk usage size in bytes of staging deals not yet
-passed to the sealing node by the markets service. 0 is unlimited.`,
+			Comment: `The maximum allowed disk usage size in bytes of downloaded deal data
+that has not yet been passed to the sealing node by boost.
+When the client makes a new deal proposal to download data from a host,
+boost checks this config value against the sum of:
+- the amount of data downloaded in the staging area
+- the amount of data that is queued for download
+- the amount of data in the proposed deal
+If the total amount would exceed the limit, boost rejects the deal.
+Set this value to 0 to indicate there is no limit.`,
 		},
 		{
-			Name: "SimultaneousTransfersForStorage",
+			Name: "MaxStagingDealsPercentPerHost",
 			Type: "uint64",
 
-			Comment: `The maximum number of parallel online data transfers for storage deals`,
-		},
-		{
-			Name: "SimultaneousTransfersForRetrieval",
-			Type: "uint64",
-
-			Comment: `The maximum number of parallel online data transfers for retrieval deals`,
+			Comment: `The percentage of MaxStagingDealsBytes that is allocated to each host.
+When the client makes a new deal proposal to download data from a host,
+boost checks this config value against the sum of:
+- the amount of data downloaded from the host in the staging area
+- the amount of data that is queued for download from the host
+- the amount of data in the proposed deal
+If the total amount would exceed the limit, boost rejects the deal.
+Set this value to 0 to indicate there is no limit per host.`,
 		},
 		{
 			Name: "StartEpochSealingBuffer",
@@ -239,6 +253,13 @@ see https://docs.filecoin.io/mine/lotus/miner-configuration/#using-filters-for-f
 
 			Comment: `Whether to do commp on the Boost node (local) or on the Sealer (remote)`,
 		},
+		{
+			Name: "MaxConcurrentLocalCommp",
+			Type: "uint64",
+
+			Comment: `The maximum number of commp processes to run in parallel on the local
+boost process`,
+		},
 		{
 			Name: "HTTPRetrievalMultiaddr",
 			Type: "string",
@@ -246,6 +267,27 @@ see https://docs.filecoin.io/mine/lotus/miner-configuration/#using-filters-for-f
 			Comment: `The public multi-address for retrieving deals with booster-http.
 Note: Must be in multiaddr format, eg /dns/foo.com/tcp/443/https`,
 		},
+		{
+			Name: "HttpTransferMaxConcurrentDownloads",
+			Type: "uint64",
+
+			Comment: `The maximum number of concurrent storage deal HTTP downloads.
+Note that this is a soft maximum; if some downloads stall,
+more downloads are allowed to start.`,
+		},
+		{
+			Name: "HttpTransferStallCheckPeriod",
+			Type: "Duration",
+
+			Comment: `The period between checking if downloads have stalled.`,
+		},
+		{
+			Name: "HttpTransferStallTimeout",
+			Type: "Duration",
+
+			Comment: `The time that can elapse before a download is considered stalled (and
+another concurrent download is allowed to start).`,
+		},
 	},
 	"FeeConfig": []DocField{
 		{
@@ -376,6 +418,26 @@ see https://docs.filecoin.io/mine/lotus/miner-configuration/#using-filters-for-f
 			Comment: `The maximum number of concurrent fetch operations to the storage subsystem`,
 		},
 	},
+	"TracingConfig": []DocField{
+		{
+			Name: "Enabled",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "ServiceName",
+			Type: "string",
+
+			Comment: ``,
+		},
+		{
+			Name: "Endpoint",
+			Type: "string",
+
+			Comment: ``,
+		},
+	},
 	"WalletsConfig": []DocField{
 		{
 			Name: "Miner",
diff --git a/node/config/migrate.go b/node/config/migrate.go
index fb7138057..42e5f98fb 100644
--- a/node/config/migrate.go
+++ b/node/config/migrate.go
@@ -15,13 +15,14 @@ var log = logging.Logger("cfg")
 
 // CurrentVersion is the config version expected by Boost.
 // We need to migrate the config file to this version.
-const CurrentVersion = 2
+const CurrentVersion = 3
 
 type migrateUpFn = func(cfgPath string) (string, error)
 
 var migrations = []migrateUpFn{
-	v0Tov1, // index 0 => version 0
-	v1Tov2, // index 1 => version 1
+	v0Tov1, // index 0 => version 1
+	v1Tov2, // index 1 => version 2
+	v2Tov3, // index 2 => version 3
 }
 
 // This struct is used to get the config file version
diff --git a/node/config/types.go b/node/config/types.go
index 7ff9c3a2d..707cb0be3 100644
--- a/node/config/types.go
+++ b/node/config/types.go
@@ -42,6 +42,7 @@ type Boost struct {
 	Dealmaking         DealmakingConfig
 	Wallets            WalletsConfig
 	Graphql            GraphqlConfig
+	Tracing            TracingConfig
 
 	// Lotus configs
 	LotusDealmaking lotus_config.DealmakingConfig
@@ -75,6 +76,12 @@ type GraphqlConfig struct {
 	Port uint64
 }
 
+type TracingConfig struct {
+	Enabled     bool
+	ServiceName string
+	Endpoint    string
+}
+
 type LotusDealmakingConfig struct {
 	// A list of Data CIDs to reject when making deals
 	PieceCidBlocklist []cid.Cid
@@ -144,13 +151,25 @@ type DealmakingConfig struct {
 	// The maximum collateral that the provider will put up against a deal,
 	// as a multiplier of the minimum collateral bound
 	MaxProviderCollateralMultiplier uint64
-	// The maximum allowed disk usage size in bytes of staging deals not yet
-	// passed to the sealing node by the markets service. 0 is unlimited.
+	// The maximum allowed disk usage size in bytes of downloaded deal data
+	// that has not yet been passed to the sealing node by boost.
+	// When the client makes a new deal proposal to download data from a host,
+	// boost checks this config value against the sum of:
+	// - the amount of data downloaded in the staging area
+	// - the amount of data that is queued for download
+	// - the amount of data in the proposed deal
+	// If the total amount would exceed the limit, boost rejects the deal.
+	// Set this value to 0 to indicate there is no limit.
 	MaxStagingDealsBytes int64
-	// The maximum number of parallel online data transfers for storage deals
-	SimultaneousTransfersForStorage uint64
-	// The maximum number of parallel online data transfers for retrieval deals
-	SimultaneousTransfersForRetrieval uint64
+	// The percentage of MaxStagingDealsBytes that is allocated to each host.
+	// When the client makes a new deal proposal to download data from a host,
+	// boost checks this config value against the sum of:
+	// - the amount of data downloaded from the host in the staging area
+	// - the amount of data that is queued for download from the host
+	// - the amount of data in the proposed deal
+	// If the total amount would exceed the limit, boost rejects the deal.
+	// Set this value to 0 to indicate there is no limit per host.
+	MaxStagingDealsPercentPerHost uint64
 	// Minimum start epoch buffer to give time for sealing of sector with deal.
 	StartEpochSealingBuffer uint64
 	// The amount of time to keep deal proposal logs for before cleaning them up.
@@ -167,12 +186,26 @@ type DealmakingConfig struct {
 
 	// The maximum amount of time a transfer can take before it fails
 	MaxTransferDuration Duration
+
 	// Whether to do commp on the Boost node (local) or on the Sealer (remote)
 	RemoteCommp bool
+	// The maximum number of commp processes to run in parallel on the local
+	// boost process
+	MaxConcurrentLocalCommp uint64
 
 	// The public multi-address for retrieving deals with booster-http.
 	// Note: Must be in multiaddr format, eg /dns/foo.com/tcp/443/https
 	HTTPRetrievalMultiaddr string
+
+	// The maximum number of concurrent storage deal HTTP downloads.
+	// Note that this is a soft maximum; if some downloads stall,
+	// more downloads are allowed to start.
+	HttpTransferMaxConcurrentDownloads uint64
+	// The period between checking if downloads have stalled.
+	HttpTransferStallCheckPeriod Duration
+	// The time that can elapse before a download is considered stalled (and
+	// another concurrent download is allowed to start).
+	HttpTransferStallTimeout Duration
 }
 
 type FeeConfig struct {
diff --git a/node/config/v2_to_v3.go b/node/config/v2_to_v3.go
new file mode 100644
index 000000000..dbc069ebc
--- /dev/null
+++ b/node/config/v2_to_v3.go
@@ -0,0 +1,28 @@
+package config
+
+import (
+	"fmt"
+)
+
+// Migrate from config version 2 to version 3 (i.e. remove a few fields and add recently added fields)
+func v2Tov3(cfgPath string) (string, error) {
+	cfg, err := FromFile(cfgPath, DefaultBoost())
+	if err != nil {
+		return "", fmt.Errorf("parsing config file %s: %w", cfgPath, err)
+	}
+
+	boostCfg, ok := cfg.(*Boost)
+	if !ok {
+		return "", fmt.Errorf("unexpected config type %T: expected *config.Boost", cfg)
+	}
+
+	// Update the Boost config version
+	boostCfg.ConfigVersion = 3
+
+	bz, err := ConfigUpdate(boostCfg, DefaultBoost(), true)
+	if err != nil {
+		return "", fmt.Errorf("applying configuration: %w", err)
+	}
+
+	return string(bz), nil
+}
diff --git a/node/impl/boost.go b/node/impl/boost.go
index 487e8caa5..49d1188bc 100644
--- a/node/impl/boost.go
+++ b/node/impl/boost.go
@@ -8,7 +8,9 @@ import (
 	"net/http"
 	"sort"
 
+	tracing "github.com/filecoin-project/boost/tracing"
 	"github.com/multiformats/go-multihash"
+	"go.opentelemetry.io/otel/attribute"
 
 	"github.com/filecoin-project/go-fil-markets/stores"
 
@@ -45,8 +47,6 @@ type BoostAPI struct {
 	api.Net
 
 	Full lapi.FullNode
-	//LocalStore  *stores.Local
-	//RemoteStore *stores.Remote
 
 	Host host.Host
 
@@ -71,10 +71,13 @@ type BoostAPI struct {
 
 	// Sealing Pipeline API
 	Sps sealingpipeline.API
-	// TODO: Figure out how to start graphql server without it needing
-	// to be a dependency of another fx object
+
+	// GraphSQL server
 	GraphqlServer *gql.Server
 
+	// Tracing
+	Tracing *tracing.Tracing
+
 	DS lotus_dtypes.MetadataDS
 
 	ConsiderOnlineStorageDealsConfigFunc        lotus_dtypes.ConsiderOnlineStorageDealsConfigFunc        `optional:"true"`
@@ -114,10 +117,16 @@ func (sm *BoostAPI) ServeRemote(perm bool) func(w http.ResponseWriter, r *http.R
 }
 
 func (sm *BoostAPI) BoostDummyDeal(ctx context.Context, params types.DealParams) (*api.ProviderDealRejectionInfo, error) {
-	return sm.StorageProvider.ExecuteDeal(&params, "dummy")
+	return sm.StorageProvider.ExecuteDeal(ctx, &params, "dummy")
 }
 
 func (sm *BoostAPI) BoostDeal(ctx context.Context, dealUuid uuid.UUID) (*types.ProviderDealState, error) {
+	// TODO: Use a middleware function that wraps the entire api implementation for all RPC calls
+	// Testing for now until a middleware function is created
+	ctx, span := tracing.Tracer.Start(ctx, "BoostAPI.BoostDeal")
+	defer span.End()
+	span.SetAttributes(attribute.String("dealUuid", dealUuid.String())) // Example of adding additional attributes
+
 	return sm.StorageProvider.Deal(ctx, dealUuid)
 }
 
@@ -129,8 +138,8 @@ func (sm *BoostAPI) BoostIndexerAnnounceAllDeals(ctx context.Context) error {
 	return sm.IndexProvider.IndexerAnnounceAllDeals(ctx)
 }
 
-func (sm *BoostAPI) BoostOfflineDealWithData(_ context.Context, dealUuid uuid.UUID, filePath string) (*api.ProviderDealRejectionInfo, error) {
-	res, err := sm.StorageProvider.ImportOfflineDealData(dealUuid, filePath)
+func (sm *BoostAPI) BoostOfflineDealWithData(ctx context.Context, dealUuid uuid.UUID, filePath string) (*api.ProviderDealRejectionInfo, error) {
+	res, err := sm.StorageProvider.ImportOfflineDealData(ctx, dealUuid, filePath)
 	return res, err
 }
 
@@ -188,6 +197,10 @@ func (sm *BoostAPI) BoostDagstoreListShards(ctx context.Context) ([]api.Dagstore
 }
 
 func (sm *BoostAPI) BoostDagstorePiecesContainingMultihash(ctx context.Context, mh multihash.Multihash) ([]cid.Cid, error) {
+	ctx, span := tracing.Tracer.Start(ctx, "Boost.BoostDagstorePiecesContainingMultihash")
+	span.SetAttributes(attribute.String("multihash", mh.String()))
+	defer span.End()
+
 	if sm.DAGStore == nil {
 		return nil, fmt.Errorf("dagstore not available on this node")
 	}
@@ -460,10 +473,6 @@ func (sm *BoostAPI) BoostDagstoreDestroyShard(ctx context.Context, key string) e
 	if err != nil {
 		return fmt.Errorf("unable to query dagstore for shard info: %w", err)
 	}
-	// If the shard is not registered we would expect ErrShardUnknown
-	if !errors.Is(err, dagstore.ErrShardUnknown) {
-		return fmt.Errorf("shard not found in the dagstore: %w", err)
-	}
 
 	pieceCid, err := cid.Parse(key)
 	if err != nil {
diff --git a/node/modules/storageminer.go b/node/modules/storageminer.go
index e506e091a..8c0788817 100644
--- a/node/modules/storageminer.go
+++ b/node/modules/storageminer.go
@@ -21,6 +21,7 @@ import (
 	"github.com/filecoin-project/boost/storagemarket/logs"
 	"github.com/filecoin-project/boost/storagemarket/lp2pimpl"
 	"github.com/filecoin-project/boost/storagemarket/types"
+	"github.com/filecoin-project/boost/tracing"
 	"github.com/filecoin-project/boost/transport/httptransport"
 	"github.com/filecoin-project/dagstore"
 	"github.com/filecoin-project/dagstore/indexbs"
@@ -405,8 +406,14 @@ func NewStorageMarketProvider(provAddr address.Address, cfg *config.Boost) func(
 		lp lotus_storagemarket.StorageProvider, cdm *storagemarket.ChainDealManager) (*storagemarket.Provider, error) {
 
 		prvCfg := storagemarket.Config{
-			MaxTransferDuration: time.Duration(cfg.Dealmaking.MaxTransferDuration),
-			RemoteCommp:         cfg.Dealmaking.RemoteCommp,
+			MaxTransferDuration:     time.Duration(cfg.Dealmaking.MaxTransferDuration),
+			RemoteCommp:             cfg.Dealmaking.RemoteCommp,
+			MaxConcurrentLocalCommp: cfg.Dealmaking.MaxConcurrentLocalCommp,
+			TransferLimiter: storagemarket.TransferLimiterConfig{
+				MaxConcurrent:    cfg.Dealmaking.HttpTransferMaxConcurrentDownloads,
+				StallCheckPeriod: time.Duration(cfg.Dealmaking.HttpTransferStallCheckPeriod),
+				StallTimeout:     time.Duration(cfg.Dealmaking.HttpTransferStallTimeout),
+			},
 		}
 		dl := logs.NewDealLogger(logsDB)
 		tspt := httptransport.New(h, dl)
@@ -505,3 +512,20 @@ func NewIndexBackedBlockstore(dagst dagstore.Interface, ps lotus_dtypes.Provider
 	}
 	return dtypes.IndexBackedBlockstore(rbs), nil
 }
+
+func NewTracing(cfg *config.Boost) func(lc fx.Lifecycle) (*tracing.Tracing, error) {
+	return func(lc fx.Lifecycle) (*tracing.Tracing, error) {
+		if cfg.Tracing.Enabled {
+			// Instantiate the tracer and exporter
+			stop, err := tracing.New(cfg.Tracing.ServiceName, cfg.Tracing.Endpoint)
+			if err != nil {
+				return nil, fmt.Errorf("failed to instantiate tracer: %w", err)
+			}
+			lc.Append(fx.Hook{
+				OnStop: stop,
+			})
+		}
+
+		return &tracing.Tracing{}, nil
+	}
+}
diff --git a/react/src/DealTransfers.css b/react/src/DealTransfers.css
new file mode 100644
index 000000000..e5c7ece5f
--- /dev/null
+++ b/react/src/DealTransfers.css
@@ -0,0 +1,23 @@
+.transfer-stats {
+    margin: 1em;
+}
+
+.transfer-stats .config {
+    margin: 2em 0 1em 0;
+}
+
+.transfer-stats table th, .transfer-stats table td {
+    padding: 0.5em 1em;
+}
+
+.transfer-stats table th {
+    text-align: left;
+}
+
+.transfer-stats table td {
+    text-align: right;
+}
+
+.transfer-stats table td.transfer-rate {
+    color: #999999;
+}
\ No newline at end of file
diff --git a/react/src/DealTransfers.js b/react/src/DealTransfers.js
index 49622fbaf..178aaf53e 100644
--- a/react/src/DealTransfers.js
+++ b/react/src/DealTransfers.js
@@ -1,12 +1,13 @@
 import React from "react";
 import {Chart} from "react-google-charts";
 import {useQuery} from "@apollo/react-hooks";
-import {TransfersQuery} from "./gql";
+import {TransfersQuery, TransferStatsQuery} from "./gql";
 import moment from "moment"
 import {PageContainer} from "./Components";
 import {Link} from "react-router-dom";
 import {toFixed} from "./util";
 import arrowLeftRightImg from './bootstrap-icons/icons/arrow-left-right.svg'
+import './DealTransfers.css'
 
 var maxMegabits = 0
 
@@ -17,6 +18,13 @@ export function DealTransfersPage(props) {
 }
 
 function DealTransfersContent(props) {
+    return <div>
+        <DealTransfersChart />
+        <TransferStats />
+    </div>
+}
+
+function DealTransfersChart(props) {
     const {loading, error, data} = useQuery(TransfersQuery, {
         pollInterval: 1000,
         fetchPolicy: 'network-only',
@@ -70,33 +78,120 @@ function DealTransfersContent(props) {
     </div>
 }
 
-export function DealTransfersMenuItem(props) {
-    const {data} = useQuery(TransfersQuery, {
-        pollInterval: 5000,
+function TransferStats(props) {
+    const {loading, error, data} = useQuery(TransferStatsQuery, {
+        pollInterval: 1000,
         fetchPolicy: 'network-only',
     })
 
+    if (loading) {
+        return <div>Loading...</div>
+    }
+    if (error) {
+        return <div>Error: {error.message}</div>
+    }
+
+    const stats = data.transferStats
+    return <div className="transfer-stats">
+        <div>
+            <h3>Transfers by Host</h3>
+            <table>
+                <tbody>
+                <tr>
+                    <th>Host</th>
+                    <th>Total</th>
+                    <th>Queued</th>
+                    <th>Active</th>
+                    <th>Stalled</th>
+                    <th>Rate</th>
+                </tr>
+                { stats.Stats.map((hostStats) => {
+                    return <tr key={hostStats.Host}>
+                        <td>{hostStats.Host}</td>
+                        <td>{hostStats.Total}</td>
+                        <td>{hostStats.Total-hostStats.Started}</td>
+                        <td>{hostStats.Started-hostStats.Stalled}</td>
+                        <td>{hostStats.Stalled}</td>
+                        <td className="transfer-rate">{getTransferRate(hostStats.TransferSamples)}</td>
+                    </tr>
+                }) }
+                </tbody>
+            </table>
+        </div>
+
+        <div className="config">
+            <h3>Config</h3>
+            <table>
+                <tbody>
+                <tr>
+                    <th>HTTP concurrent download limit:</th>
+                    <td>{stats.HttpMaxConcurrentDownloads}</td>
+                </tr>
+                </tbody>
+            </table>
+        </div>
+    </div>
+}
+
+function getTransferRate(samples) {
     var dataRate = 0
-    if (data && data.transfers.length) {
+    if (samples && samples.length) {
         // Clone from read-only to writable array
-        var points = data.transfers.map(p => ({At: p.At, Bytes: p.Bytes}))
+        var points = samples.map(p => ({At: p.At, Bytes: p.Bytes}))
         points.sort((a, b) => a.At.getTime() - b.At.getTime())
 
         // Get average transfer rate over last 10 seconds
+        const subset = points.slice(-10)
+        // Allow for some clock skew, but ignore samples older than 2 minutes
+        const cutOff = new Date(new Date().getTime() - 2*60*1000)
         var total = 0
-        const subset = points.slice(points.length-10)
+        var count = 0
         for (const point of subset) {
-            const megabits = 8 * Number(point.Bytes) / 1e6
-            total += megabits
+            if (point.At > cutOff) {
+                total += Number(point.Bytes)
+                count++
+            }
         }
-        dataRate = total / subset.length
+        if (count > 0) {
+            dataRate = total / count
+        }
+    }
+    return humanTransferRate(dataRate)
+}
+
+export function humanTransferRate(bytesPerSecond) {
+    // Convert from bytes to kbps or Mbps
+    var transferRate = ""
+    const kbps = (bytesPerSecond*8) / 1024
+    if (kbps < 1024) {
+        if (kbps < 10) {
+            return kbps.toFixed(2) + " kbps"
+        }
+        return kbps.toFixed(1) + " kbps"
+    }
+    const mbps = kbps / 1024
+    if (mbps < 10) {
+        return mbps.toFixed(2) + " Mbps"
+    }
+    return mbps.toFixed(1) + " Mbps"
+}
+
+export function DealTransfersMenuItem(props) {
+    const {data} = useQuery(TransfersQuery, {
+        pollInterval: 5000,
+        fetchPolicy: 'network-only',
+    })
+
+    var dataRate = ""
+    if (data && data.transfers) {
+        dataRate = getTransferRate(data.transfers)
     }
 
     return <Link key="deal-transfers" className="menu-item" to="/deal-transfers">
         <img className="icon" alt="" src={arrowLeftRightImg} />
         <h3>Deal Transfers</h3>
         <div className="menu-desc">
-            <b>{toFixed(dataRate, 1)}</b> Mbps (10s avg)
+            <b>{dataRate}</b> (10s avg)
         </div>
     </Link>
 }
diff --git a/react/src/Deals.css b/react/src/Deals.css
index 0fa422829..e36d35498 100644
--- a/react/src/Deals.css
+++ b/react/src/Deals.css
@@ -51,6 +51,11 @@
     flex-grow: 1;
 }
 
+.deals tr.show-actions td.message .message-content .message-text .transfer-rate {
+    padding-left: 1em;
+    color: #999999;
+}
+
 .deals tr.show-actions td.message .buttons {
     display: inline-block;
     min-width: 6em;
diff --git a/react/src/Deals.js b/react/src/Deals.js
index 59d66e02c..7dd1649cd 100644
--- a/react/src/Deals.js
+++ b/react/src/Deals.js
@@ -1,3 +1,4 @@
+/* global BigInt */
 import {useQuery} from "@apollo/react-hooks";
 import {
     DealsCountQuery,
@@ -18,6 +19,7 @@ import xImg from './bootstrap-icons/icons/x-lg.svg'
 import './Deals.css'
 import {Pagination} from "./Pagination";
 import {DealActions, IsPaused, IsTransferring} from "./DealDetail";
+import {humanTransferRate} from "./DealTransfers";
 
 const dealsBasePath = '/storage-deals'
 
@@ -174,6 +176,7 @@ function DealRow(props) {
                 <div className="message-content">
                     <span className="message-text">
                         {deal.Message}
+                        <TransferRate deal={deal} />
                     </span>
                     {showActions ? <DealActions deal={props.deal} refetchQueries={[DealsListQuery]} compact={true} /> : null}
                 </div>
@@ -182,6 +185,41 @@ function DealRow(props) {
     )
 }
 
+function TransferRate({deal}) {
+    if (!IsTransferring(deal) || IsPaused(deal) || deal.Transferred === 0 || deal.IsTransferStalled) {
+        return null
+    }
+
+    if(deal.TransferSamples.length < 2) {
+        return null
+    }
+
+    // Clone from read-only to writable array and sort points
+    var points = deal.TransferSamples.map(p => ({ At: p.At, Bytes: p.Bytes }))
+    points.sort((a, b) => a.At.getTime() - b.At.getTime())
+
+    // Get the average rate from the last 10 seconds of samples.
+    points = points.slice(-10)
+    // Allow for some clock skew, but ignore samples older than 2 minutes
+    const cutOff = new Date(new Date().getTime() - 2*60*1000)
+    var samples = []
+    for (const pt of points) {
+        if (pt.At > cutOff) {
+            samples.push(pt)
+        }
+    }
+    if (!samples.length) {
+        return null
+    }
+
+    // Get the delta between the first sample and last sample.
+    const delta = samples[samples.length-1].Bytes - samples[0].Bytes
+
+    return <span className="transfer-rate">
+        {humanTransferRate(Number(delta) / samples.length)}
+    </span>
+}
+
 export function StorageDealsMenuItem(props) {
     const {data} = useQuery(DealsCountQuery, {
         pollInterval: 5000,
diff --git a/react/src/gql.js b/react/src/gql.js
index 999ee87b6..c980942d9 100644
--- a/react/src/gql.js
+++ b/react/src/gql.js
@@ -87,6 +87,12 @@ const DealsListQuery = gql`
                     Size
                     Params
                 }
+                Transferred
+                TransferSamples {
+                    At
+                    Bytes
+                }
+                IsTransferStalled
                 Sector {
                     ID
                     Offset
@@ -454,6 +460,24 @@ const TransfersQuery = gql`
     }
 `;
 
+const TransferStatsQuery = gql`
+    query AppTransferStatsQuery {
+        transferStats {
+            HttpMaxConcurrentDownloads
+            Stats {
+                Host
+                Total
+                Started
+                Stalled
+                TransferSamples {
+                    At
+                    Bytes
+                }
+            }
+        }
+    }
+`;
+
 const FundsLogsQuery = gql`
     query AppFundsLogsQuery($cursor: BigInt, $offset: Int, $limit: Int) {
         fundsLogs(cursor: $cursor, offset: $offset, limit: $limit) {
@@ -573,6 +597,7 @@ export {
     FundsMoveToEscrow,
     StorageAskUpdate,
     TransfersQuery,
+    TransferStatsQuery,
     MpoolQuery,
     SealingPipelineQuery,
     Libp2pAddrInfoQuery,
diff --git a/scripts/version-check.sh b/scripts/version-check.sh
old mode 100644
new mode 100755
diff --git a/storagemanager/storagemanager.go b/storagemanager/storagemanager.go
index cce5db32b..36b60fc52 100644
--- a/storagemanager/storagemanager.go
+++ b/storagemanager/storagemanager.go
@@ -22,7 +22,8 @@ var (
 )
 
 type Config struct {
-	MaxStagingDealsBytes uint64
+	MaxStagingDealsBytes          uint64
+	MaxStagingDealsPercentPerHost uint64
 }
 
 type StorageManager struct {
@@ -34,6 +35,10 @@ type StorageManager struct {
 
 func New(cfg Config) func(lr lotus_repo.LockedRepo, sqldb *sql.DB) (*StorageManager, error) {
 	return func(lr lotus_repo.LockedRepo, sqldb *sql.DB) (*StorageManager, error) {
+		if cfg.MaxStagingDealsPercentPerHost > 100 {
+			return nil, fmt.Errorf("MaxStagingDealsPercentPerHost is %d but it must be a percentage between 0 - 100", cfg.MaxStagingDealsPercentPerHost)
+		}
+
 		stagingPath := filepath.Join(lr.Path(), StagingAreaDirName)
 		err := os.MkdirAll(stagingPath, os.ModePerm)
 		if err != nil {
@@ -65,16 +70,35 @@ var ErrNoSpaceLeft = errors.New("no space left")
 
 // Tags storage space for the deal.
 // If there is not enough space left, returns ErrNoSpaceLeft.
-func (m *StorageManager) Tag(ctx context.Context, dealUuid uuid.UUID, size uint64) error {
+func (m *StorageManager) Tag(ctx context.Context, dealUuid uuid.UUID, size uint64, host string) error {
 	// Get the total tagged storage, so that we know how much is available.
-	log.Debugw("tagging", "id", dealUuid, "size", size, "maxbytes", m.cfg.MaxStagingDealsBytes)
-
-	tagged, err := m.TotalTagged(ctx)
-	if err != nil {
-		return fmt.Errorf("getting total tagged: %w", err)
-	}
+	log.Debugw("tagging", "id", dealUuid, "size", size, "host", host, "maxbytes", m.cfg.MaxStagingDealsBytes)
 
 	if m.cfg.MaxStagingDealsBytes != 0 {
+		if m.cfg.MaxStagingDealsPercentPerHost != 0 {
+			// Get the total amount tagged for download from the host
+			tagged, err := m.TotalTaggedForHost(ctx, host)
+			if err != nil {
+				return fmt.Errorf("getting total tagged for host: %w", err)
+			}
+
+			// Check the amount tagged + the size of the proposed deal against the limit
+			limit := (m.cfg.MaxStagingDealsBytes * m.cfg.MaxStagingDealsPercentPerHost) / 100
+			if tagged+size >= limit {
+				return fmt.Errorf("%w: cannot accept piece of size %d from host %s, "+
+					"on top of already allocated %d bytes, because it would exceed max %d bytes: "+
+					"staging area size %d x per host limit %d%%",
+					ErrNoSpaceLeft, size, host, tagged, limit, m.cfg.MaxStagingDealsBytes, m.cfg.MaxStagingDealsPercentPerHost)
+			}
+		}
+
+		// Get the total amount tagged for download from all hosts
+		tagged, err := m.TotalTagged(ctx)
+		if err != nil {
+			return fmt.Errorf("getting total tagged: %w", err)
+		}
+
+		// Check the amount tagged + the size of the proposed deal against the limit
 		if tagged+size >= m.cfg.MaxStagingDealsBytes {
 			err := fmt.Errorf("%w: cannot accept piece of size %d, on top of already allocated %d bytes, because it would exceed max staging area size %d",
 				ErrNoSpaceLeft, size, tagged, m.cfg.MaxStagingDealsBytes)
@@ -82,7 +106,7 @@ func (m *StorageManager) Tag(ctx context.Context, dealUuid uuid.UUID, size uint6
 		}
 	}
 
-	err = m.persistTagged(ctx, dealUuid, size)
+	err := m.persistTagged(ctx, dealUuid, size, host)
 	if err != nil {
 		return fmt.Errorf("saving total tagged storage: %w", err)
 	}
@@ -119,8 +143,16 @@ func (m *StorageManager) TotalTagged(ctx context.Context) (uint64, error) {
 	return total, nil
 }
 
-func (m *StorageManager) persistTagged(ctx context.Context, dealUuid uuid.UUID, size uint64) error {
-	err := m.db.Tag(ctx, dealUuid, size)
+func (m *StorageManager) TotalTaggedForHost(ctx context.Context, host string) (uint64, error) {
+	total, err := m.db.TotalTaggedForHost(ctx, host)
+	if err != nil {
+		return 0, fmt.Errorf("getting total tagged for host from DB: %w", err)
+	}
+	return total, nil
+}
+
+func (m *StorageManager) persistTagged(ctx context.Context, dealUuid uuid.UUID, size uint64, host string) error {
+	err := m.db.Tag(ctx, dealUuid, size, host)
 	if err != nil {
 		return fmt.Errorf("persisting tagged storage for deal to DB: %w", err)
 	}
diff --git a/storagemarket/deal_commp.go b/storagemarket/deal_commp.go
index 45a73fdf1..e5614ee01 100644
--- a/storagemarket/deal_commp.go
+++ b/storagemarket/deal_commp.go
@@ -39,6 +39,7 @@ func (p *Provider) verifyCommP(deal *types.ProviderDealState) *dealMakingError {
 // generatePieceCommitment generates commp either locally or remotely,
 // depending on config, and pads it as necessary to match the piece size.
 func (p *Provider) generatePieceCommitment(filepath string, pieceSize abi.PaddedPieceSize) (cid.Cid, *dealMakingError) {
+	// Check whether to send commp to a remote process or do it locally
 	var pi *abi.PieceInfo
 	if p.config.RemoteCommp {
 		var err *dealMakingError
@@ -48,6 +49,10 @@ func (p *Provider) generatePieceCommitment(filepath string, pieceSize abi.Padded
 			return cid.Undef, err
 		}
 	} else {
+		// Throttle the number of processes that can do local commp in parallel
+		p.commpThrottle <- struct{}{}
+		defer func() { <-p.commpThrottle }()
+
 		var err error
 		pi, err = GenerateCommP(filepath)
 		if err != nil {
diff --git a/storagemarket/deal_execution.go b/storagemarket/deal_execution.go
index 4bac3b7aa..9d40484cb 100644
--- a/storagemarket/deal_execution.go
+++ b/storagemarket/deal_execution.go
@@ -111,15 +111,16 @@ func (p *Provider) execDeal(deal *smtypes.ProviderDealState, dh *dealHandler) *d
 		return derr
 	}
 
-	p.dealLogger.Infow(deal.DealUuid, "deal execution completed successfully")
 	// deal has been sent for sealing -> we can cleanup the deal state now and simply watch the deal on chain
 	// to wait for deal completion/slashing and update the state in DB accordingly.
 	p.cleanupDeal(deal)
 	p.dealLogger.Infow(deal.DealUuid, "finished deal cleanup after successful execution")
 
 	// Watch the sealing status of the deal and fire events for each change
+	p.dealLogger.Infow(deal.DealUuid, "watching deal sealing state changes")
 	p.fireSealingUpdateEvents(dh, deal.DealUuid, deal.SectorID)
 	p.cleanupDealHandler(deal.DealUuid)
+	p.dealLogger.Infow(deal.DealUuid, "deal sealing reached termination state")
 
 	// TODO
 	// Watch deal on chain and change state in DB and emit notifications.
@@ -143,35 +144,11 @@ func (p *Provider) execDealUptoAddPiece(ctx context.Context, deal *types.Provide
 				return derr
 			}
 
-			if err := p.transferAndVerify(dh.transferCtx, pub, deal); err != nil {
+			if err := p.transferAndVerify(dh, pub, deal); err != nil {
 				// The transfer has failed. If the user tries to cancel the
 				// transfer after this point it's a no-op.
 				dh.setCancelTransferResponse(nil)
 
-				// Pass through fatal errors
-				if err.retry == smtypes.DealRetryFatal {
-					return err
-				}
-
-				// If the transfer failed because the user cancelled the
-				// transfer, it's non-recoverable
-				if dh.TransferCancelledByUser() {
-					return &dealMakingError{
-						retry: types.DealRetryFatal,
-						error: fmt.Errorf("data transfer cancelled after %d bytes: %w", deal.NBytesReceived, err),
-					}
-				}
-
-				// If the transfer failed because boost was shut down, it's
-				// automatically recoverable
-				if errors.Is(err.error, context.Canceled) {
-					return &dealMakingError{
-						retry: types.DealRetryAuto,
-						error: fmt.Errorf("data transfer paused by boost shutdown after %d bytes: %w", deal.NBytesReceived, err),
-					}
-				}
-
-				// Pass through any other transfer failure
 				return err
 			}
 
@@ -286,10 +263,42 @@ func (p *Provider) untagFundsAfterPublish(ctx context.Context, deal *types.Provi
 	}
 }
 
-func (p *Provider) transferAndVerify(ctx context.Context, pub event.Emitter, deal *types.ProviderDealState) *dealMakingError {
-	p.dealLogger.Infow(deal.DealUuid, "transferring deal data", "transfer client id", deal.Transfer.ClientID)
+func (p *Provider) transferAndVerify(dh *dealHandler, pub event.Emitter, deal *smtypes.ProviderDealState) *dealMakingError {
+	// Use a context specifically for transfers, that can be cancelled by the user
+	ctx := dh.transferCtx
+
+	p.dealLogger.Infow(deal.DealUuid, "deal queued for transfer", "transfer client id", deal.Transfer.ClientID)
+
+	// Wait for a spot in the transfer queue
+	err := p.xferLimiter.waitInQueue(ctx, deal)
+	if err != nil {
+		// If the transfer failed because the user cancelled the
+		// transfer, it's non-recoverable
+		if dh.TransferCancelledByUser() {
+			return &dealMakingError{
+				retry: types.DealRetryFatal,
+				error: fmt.Errorf("data transfer manually cancelled by user: %w", err),
+			}
+		}
+
+		// If boost was shutdown while waiting for the transfer to start,
+		// automatically retry on restart.
+		if errors.Is(err, context.Canceled) {
+			return &dealMakingError{
+				retry: smtypes.DealRetryAuto,
+				error: fmt.Errorf("boost shutdown while waiting to start transfer for deal %s: %w", deal.DealUuid, err),
+			}
+		}
+		return &dealMakingError{
+			retry: smtypes.DealRetryFatal,
+			error: fmt.Errorf("queued transfer failed to start for deal %s: %w", deal.DealUuid, err),
+		}
+	}
+	defer p.xferLimiter.complete(deal.DealUuid)
 
-	tctx, cancel := context.WithDeadline(ctx, time.Now().Add(p.config.MaxTransferDuration))
+	p.dealLogger.Infow(deal.DealUuid, "start deal data transfer", "transfer client id", deal.Transfer.ClientID)
+	transferStart := time.Now()
+	tctx, cancel := context.WithDeadline(ctx, transferStart.Add(p.config.MaxTransferDuration))
 	defer cancel()
 
 	st := time.Now()
@@ -307,15 +316,36 @@ func (p *Provider) transferAndVerify(ctx context.Context, pub event.Emitter, dea
 
 	// wait for data-transfer to finish
 	if err := p.waitForTransferFinish(tctx, handler, pub, deal); err != nil {
+		// If the transfer failed because the user cancelled the
+		// transfer, it's non-recoverable
+		if dh.TransferCancelledByUser() {
+			return &dealMakingError{
+				retry: types.DealRetryFatal,
+				error: fmt.Errorf("data transfer manually cancelled by user after %d bytes: %w", deal.NBytesReceived, err),
+			}
+		}
+
+		// If the transfer failed because boost was shut down, it's
+		// automatically recoverable
+		if errors.Is(err, context.Canceled) && time.Since(transferStart) < p.config.MaxTransferDuration {
+			return &dealMakingError{
+				retry: types.DealRetryAuto,
+				error: fmt.Errorf("data transfer paused by boost shutdown after %d bytes: %w", deal.NBytesReceived, err),
+			}
+		}
+
 		// Note that the data transfer has automatic retries built in, so if
 		// it fails, it means it's already retried several times and we should
-		// surface the problem to the user so they can decide manually whether
-		// to keep retrying
+		// fail the deal
 		return &dealMakingError{
-			retry: smtypes.DealRetryManual,
+			retry: smtypes.DealRetryFatal,
 			error: fmt.Errorf("data-transfer failed: %w", err),
 		}
 	}
+
+	// Make room in the transfer queue for the next transfer
+	p.xferLimiter.complete(deal.DealUuid)
+
 	p.dealLogger.Infow(deal.DealUuid, "deal data-transfer completed successfully", "bytes received", deal.NBytesReceived, "time taken",
 		time.Since(st).String())
 
@@ -332,8 +362,9 @@ func (p *Provider) transferAndVerify(ctx context.Context, pub event.Emitter, dea
 func (p *Provider) waitForTransferFinish(ctx context.Context, handler transport.Handler, pub event.Emitter, deal *types.ProviderDealState) error {
 	defer handler.Close()
 	defer p.transfers.complete(deal.DealUuid)
-	var lastOutputPct int64
 
+	// log transfer progress to the deal log every 10%
+	var lastOutputPct int64
 	logTransferProgress := func(received int64) {
 		pct := (100 * received) / int64(deal.Transfer.Size)
 		outputPct := pct / 10
@@ -355,6 +386,7 @@ func (p *Provider) waitForTransferFinish(ctx context.Context, handler transport.
 			}
 			deal.NBytesReceived = evt.NBytesReceived
 			p.transfers.setBytes(deal.DealUuid, uint64(evt.NBytesReceived))
+			p.xferLimiter.setBytes(deal.DealUuid, uint64(evt.NBytesReceived))
 			p.fireEventDealUpdate(pub, deal)
 			logTransferProgress(deal.NBytesReceived)
 
@@ -607,6 +639,7 @@ func (p *Provider) fireSealingUpdateEvents(dh *dealHandler, dealUuid uuid.UUID,
 				return si.State
 			}
 
+			p.dealLogger.Infow(dealUuid, "current sealing state", "state", si.State)
 			p.fireEventDealUpdate(dh.Publisher, deal)
 		}
 		return si.State
diff --git a/storagemarket/lp2pimpl/net.go b/storagemarket/lp2pimpl/net.go
index 8c51de713..87087313a 100644
--- a/storagemarket/lp2pimpl/net.go
+++ b/storagemarket/lp2pimpl/net.go
@@ -199,7 +199,7 @@ func (p *DealProvider) handleNewDealStream(s network.Stream) {
 	// Start executing the deal.
 	// Note: This method just waits for the deal to be accepted, it doesn't
 	// wait for deal execution to complete.
-	res, err := p.prov.ExecuteDeal(&proposal, s.Conn().RemotePeer())
+	res, err := p.prov.ExecuteDeal(context.Background(), &proposal, s.Conn().RemotePeer())
 	if err != nil {
 		log.Warnw("deal proposal failed", "id", proposal.DealUUID, "err", err, "reason", res.Reason)
 	}
diff --git a/storagemarket/provider.go b/storagemarket/provider.go
index c53267c7c..feaec8dc4 100644
--- a/storagemarket/provider.go
+++ b/storagemarket/provider.go
@@ -22,6 +22,7 @@ import (
 	"github.com/filecoin-project/boost/storagemarket/types"
 	smtypes "github.com/filecoin-project/boost/storagemarket/types"
 	"github.com/filecoin-project/boost/storagemarket/types/dealcheckpoints"
+	"github.com/filecoin-project/boost/tracing"
 	"github.com/filecoin-project/boost/transport"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
@@ -38,6 +39,7 @@ import (
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p-core/event"
 	"github.com/libp2p/go-libp2p-core/peer"
+	"go.opentelemetry.io/otel/attribute"
 )
 
 var (
@@ -55,6 +57,9 @@ type Config struct {
 	MaxTransferDuration time.Duration
 	// Whether to do commp on the Boost node (local) or the sealing node (remote)
 	RemoteCommp bool
+	// The number of commp processes that can run in parallel
+	MaxConcurrentLocalCommp uint64
+	TransferLimiter         TransferLimiterConfig
 }
 
 var log = logging.Logger("boost-provider")
@@ -91,12 +96,14 @@ type Provider struct {
 	logsDB    *db.LogsDB
 
 	Transport      transport.Transport
+	xferLimiter    *transferLimiter
 	fundManager    *fundmanager.FundManager
 	storageManager *storagemanager.StorageManager
 	dealPublisher  types.DealPublisher
 	transfers      *dealTransfers
 
 	pieceAdder                  types.PieceAdder
+	commpThrottle               chan struct{}
 	commpCalc                   smtypes.CommpCalculator
 	maxDealCollateralMultiplier uint64
 	chainDealManager            types.ChainDealManager
@@ -122,12 +129,22 @@ func NewProvider(cfg Config, sqldb *sql.DB, dealsDB *db.DealsDB, fundMgr *fundma
 	dagst stores.DAGStoreWrapper, ps piecestore.PieceStore, ip types.IndexProvider, askGetter types.AskGetter,
 	sigVerifier types.SignatureVerifier, dl *logs.DealLogger, tspt transport.Transport) (*Provider, error) {
 
+	xferLimiter, err := newTransferLimiter(cfg.TransferLimiter)
+	if err != nil {
+		return nil, err
+	}
+
 	newDealPS, err := newDealPubsub()
 	if err != nil {
 		return nil, err
 	}
 	ctx, cancel := context.WithCancel(context.Background())
 
+	// Make sure that max concurrent local commp is at least 1
+	if cfg.MaxConcurrentLocalCommp == 0 {
+		cfg.MaxConcurrentLocalCommp = 1
+	}
+
 	return &Provider{
 		ctx:       ctx,
 		cancel:    cancel,
@@ -147,12 +164,14 @@ func NewProvider(cfg Config, sqldb *sql.DB, dealsDB *db.DealsDB, fundMgr *fundma
 		storageSpaceChan:     make(chan storageSpaceDealReq),
 
 		Transport:      tspt,
+		xferLimiter:    xferLimiter,
 		fundManager:    fundMgr,
 		storageManager: storageMgr,
 
 		dealPublisher:               dp,
 		fullnodeApi:                 fullnodeApi,
 		pieceAdder:                  pa,
+		commpThrottle:               make(chan struct{}, cfg.MaxConcurrentLocalCommp),
 		commpCalc:                   commpCalc,
 		chainDealManager:            cm,
 		maxDealCollateralMultiplier: 2,
@@ -172,6 +191,10 @@ func NewProvider(cfg Config, sqldb *sql.DB, dealsDB *db.DealsDB, fundMgr *fundma
 }
 
 func (p *Provider) Deal(ctx context.Context, dealUuid uuid.UUID) (*types.ProviderDealState, error) {
+	ctx, span := tracing.Tracer.Start(ctx, "Provider.Deal")
+	defer span.End()
+	span.SetAttributes(attribute.String("dealUuid", dealUuid.String())) // Example of adding additional attributes
+
 	deal, err := p.dealsDB.ByID(ctx, dealUuid)
 	if errors.Is(err, sql.ErrNoRows) {
 		return nil, fmt.Errorf("getting deal %s: %w", dealUuid, ErrDealNotFound)
@@ -187,17 +210,13 @@ func (p *Provider) DealBySignedProposalCid(ctx context.Context, propCid cid.Cid)
 	return deal, nil
 }
 
-func (p *Provider) NBytesReceived(dealUuid uuid.UUID) uint64 {
-	return p.transfers.getBytes(dealUuid)
-}
-
 func (p *Provider) GetAsk() *storagemarket.SignedStorageAsk {
 	return p.askGetter.GetAsk()
 }
 
 // ImportOfflineDealData is called when the Storage Provider imports data for
 // an offline deal (the deal must already have been proposed by the client)
-func (p *Provider) ImportOfflineDealData(dealUuid uuid.UUID, filePath string) (pi *api.ProviderDealRejectionInfo, err error) {
+func (p *Provider) ImportOfflineDealData(ctx context.Context, dealUuid uuid.UUID, filePath string) (pi *api.ProviderDealRejectionInfo, err error) {
 	p.dealLogger.Infow(dealUuid, "import data for offline deal", "filepath", filePath)
 
 	// db should already have a deal with this uuid as the deal proposal should have been agreed before hand
@@ -217,7 +236,7 @@ func (p *Provider) ImportOfflineDealData(dealUuid uuid.UUID, filePath string) (p
 
 	ds.InboundFilePath = filePath
 
-	resp, err := p.checkForDealAcceptance(ds, true)
+	resp, err := p.checkForDealAcceptance(ctx, ds, true)
 	if err != nil {
 		p.dealLogger.LogError(dealUuid, "failed to send deal for acceptance", err)
 		return nil, fmt.Errorf("failed to send deal for acceptance: %w", err)
@@ -240,7 +259,12 @@ func (p *Provider) ImportOfflineDealData(dealUuid uuid.UUID, filePath string) (p
 
 // ExecuteDeal is called when the Storage Provider receives a deal proposal
 // from the network
-func (p *Provider) ExecuteDeal(dp *types.DealParams, clientPeer peer.ID) (*api.ProviderDealRejectionInfo, error) {
+func (p *Provider) ExecuteDeal(ctx context.Context, dp *types.DealParams, clientPeer peer.ID) (*api.ProviderDealRejectionInfo, error) {
+	ctx, span := tracing.Tracer.Start(ctx, "Provider.ExecuteDeal")
+	defer span.End()
+
+	span.SetAttributes(attribute.String("dealUuid", dp.DealUUID.String())) // Example of adding additional attributes
+
 	p.dealLogger.Infow(dp.DealUUID, "executing deal proposal received from network", "peer", clientPeer)
 
 	ds := types.ProviderDealState{
@@ -265,14 +289,17 @@ func (p *Provider) ExecuteDeal(dp *types.DealParams, clientPeer peer.ID) (*api.P
 		}, nil
 	}
 
-	return p.executeDeal(ds)
+	return p.executeDeal(ctx, ds)
 }
 
 // executeDeal sends the deal to the main provider run loop for execution
-func (p *Provider) executeDeal(ds smtypes.ProviderDealState) (*api.ProviderDealRejectionInfo, error) {
+func (p *Provider) executeDeal(ctx context.Context, ds smtypes.ProviderDealState) (*api.ProviderDealRejectionInfo, error) {
+	ctx, span := tracing.Tracer.Start(ctx, "Provider.executeDeal")
+	defer span.End()
+
 	ri, err := func() (*api.ProviderDealRejectionInfo, error) {
 		// send the deal to the main provider loop for execution
-		resp, err := p.checkForDealAcceptance(&ds, false)
+		resp, err := p.checkForDealAcceptance(ctx, &ds, false)
 		if err != nil {
 			p.dealLogger.LogError(ds.DealUuid, "failed to send deal for acceptance", err)
 			return nil, fmt.Errorf("failed to send deal for acceptance: %w", err)
@@ -304,7 +331,10 @@ func (p *Provider) executeDeal(ds smtypes.ProviderDealState) (*api.ProviderDealR
 	return ri, nil
 }
 
-func (p *Provider) checkForDealAcceptance(ds *types.ProviderDealState, isImport bool) (acceptDealResp, error) {
+func (p *Provider) checkForDealAcceptance(ctx context.Context, ds *types.ProviderDealState, isImport bool) (acceptDealResp, error) {
+	_, span := tracing.Tracer.Start(ctx, "Provider.checkForDealAcceptance")
+	defer span.End()
+
 	// send message to run loop to run the deal through the acceptance filter and reserve the required resources
 	// then wait for a response and return the response to the client.
 	respChan := make(chan acceptDealResp, 1)
@@ -421,6 +451,9 @@ func (p *Provider) Start() error {
 	// Start sampling transfer data rate
 	go p.transfers.start(p.ctx)
 
+	// Start the transfer limiter
+	go p.xferLimiter.run(p.ctx)
+
 	log.Infow("storage provider: started")
 	return nil
 }
diff --git a/storagemarket/provider_loop.go b/storagemarket/provider_loop.go
index 3d29a1cb6..60bbe9dc7 100644
--- a/storagemarket/provider_loop.go
+++ b/storagemarket/provider_loop.go
@@ -71,6 +71,15 @@ type acceptError struct {
 }
 
 func (p *Provider) processDealProposal(deal *types.ProviderDealState) *acceptError {
+	host, err := deal.Transfer.Host()
+	if err != nil {
+		return &acceptError{
+			error:         fmt.Errorf("failed to get deal transfer host: %w", err),
+			reason:        fmt.Sprintf("server error: get deal transfer host: %s", err),
+			isSevereError: false,
+		}
+	}
+
 	// Check that the deal proposal is unique
 	if aerr := p.checkDealPropUnique(deal); aerr != nil {
 		return aerr
@@ -85,13 +94,14 @@ func (p *Provider) processDealProposal(deal *types.ProviderDealState) *acceptErr
 	status, err := sealingpipeline.GetStatus(p.ctx, p.fullnodeApi, p.sps)
 	if err != nil {
 		return &acceptError{
-			error:         fmt.Errorf("failed to fetch sealing pipleine status: %w", err),
+			error:         fmt.Errorf("failed to fetch sealing pipeline status: %w", err),
 			reason:        "server error: get sealing status",
 			isSevereError: true,
 		}
 	}
 
-	// run custom decision logic
+	// run custom decision logic by invoking the deal filter
+	// (the deal filter can be configured by the user)
 	params := types.DealParams{
 		DealUUID:           deal.DealUuid,
 		ClientDealProposal: deal.ClientDealProposal,
@@ -161,7 +171,7 @@ func (p *Provider) processDealProposal(deal *types.ProviderDealState) *acceptErr
 	p.logFunds(deal.DealUuid, trsp)
 
 	// tag the storage required for the deal in the staging area
-	err = p.storageManager.Tag(p.ctx, deal.DealUuid, deal.Transfer.Size)
+	err = p.storageManager.Tag(p.ctx, deal.DealUuid, deal.Transfer.Size, host)
 	if err != nil {
 		cleanup()
 
diff --git a/storagemarket/provider_offline_test.go b/storagemarket/provider_offline_test.go
index 928406cfb..392c0ee71 100644
--- a/storagemarket/provider_offline_test.go
+++ b/storagemarket/provider_offline_test.go
@@ -73,13 +73,13 @@ func TestOfflineDealInsufficientProviderFunds(t *testing.T) {
 	td := harness.newDealBuilder(t, 1, withOfflineDeal()).withNoOpMinerStub().build()
 
 	// create a deal proposal for the offline deal
-	pi, err := harness.Provider.ExecuteDeal(td.params, peer.ID(""))
+	pi, err := harness.Provider.ExecuteDeal(context.Background(), td.params, peer.ID(""))
 	require.NoError(t, err)
 	require.True(t, pi.Accepted)
 
 	// expect that when the deal data is imported, the import will fail because
 	// there are not enough funds for the deal
-	pi, err = td.ph.Provider.ImportOfflineDealData(td.params.DealUUID, td.carv2FilePath)
+	pi, err = td.ph.Provider.ImportOfflineDealData(context.Background(), td.params.DealUUID, td.carv2FilePath)
 	require.NoError(t, err)
 	require.False(t, pi.Accepted)
 	require.Contains(t, pi.Reason, "insufficient funds")
diff --git a/storagemarket/provider_test.go b/storagemarket/provider_test.go
index 1543616d9..7a08d0ded 100644
--- a/storagemarket/provider_test.go
+++ b/storagemarket/provider_test.go
@@ -320,7 +320,7 @@ func TestDealRejectedForDuplicateProposal(t *testing.T) {
 		err := td.executeAndSubscribe()
 		require.NoError(t, err)
 
-		pi, err := td.ph.Provider.ExecuteDeal(td.params, "")
+		pi, err := td.ph.Provider.ExecuteDeal(context.Background(), td.params, "")
 		require.NoError(t, err)
 		require.False(t, pi.Accepted)
 		require.Contains(t, pi.Reason, "deal proposal is identical")
@@ -328,10 +328,10 @@ func TestDealRejectedForDuplicateProposal(t *testing.T) {
 
 	t.Run("offline", func(t *testing.T) {
 		td := harness.newDealBuilder(t, 1, withOfflineDeal()).withNoOpMinerStub().build()
-		_, err := td.ph.Provider.ExecuteDeal(td.params, "")
+		_, err := td.ph.Provider.ExecuteDeal(context.Background(), td.params, "")
 		require.NoError(t, err)
 
-		pi, err := td.ph.Provider.ExecuteDeal(td.params, "")
+		pi, err := td.ph.Provider.ExecuteDeal(context.Background(), td.params, "")
 		require.NoError(t, err)
 		require.False(t, pi.Accepted)
 		require.Contains(t, pi.Reason, "deal proposal is identical")
@@ -352,7 +352,7 @@ func TestDealRejectedForDuplicateUuid(t *testing.T) {
 
 		td2 := harness.newDealBuilder(t, 2).withNoOpMinerStub().withBlockingHttpServer().build()
 		td2.params.DealUUID = td.params.DealUUID
-		pi, err := td.ph.Provider.ExecuteDeal(td2.params, "")
+		pi, err := td.ph.Provider.ExecuteDeal(context.Background(), td2.params, "")
 		require.NoError(t, err)
 		require.False(t, pi.Accepted)
 		require.Contains(t, pi.Reason, "deal has the same uuid")
@@ -360,12 +360,12 @@ func TestDealRejectedForDuplicateUuid(t *testing.T) {
 
 	t.Run("offline", func(t *testing.T) {
 		td := harness.newDealBuilder(t, 1, withOfflineDeal()).withNoOpMinerStub().build()
-		_, err := td.ph.Provider.ExecuteDeal(td.params, "")
+		_, err := td.ph.Provider.ExecuteDeal(context.Background(), td.params, "")
 		require.NoError(t, err)
 
 		td2 := harness.newDealBuilder(t, 2, withOfflineDeal()).withNoOpMinerStub().build()
 		td2.params.DealUUID = td.params.DealUUID
-		pi, err := td.ph.Provider.ExecuteDeal(td2.params, "")
+		pi, err := td.ph.Provider.ExecuteDeal(context.Background(), td2.params, "")
 		require.NoError(t, err)
 		require.False(t, pi.Accepted)
 		require.Contains(t, pi.Reason, "deal has the same uuid")
@@ -382,7 +382,7 @@ func TestDealRejectedForInsufficientProviderFunds(t *testing.T) {
 	defer harness.Stop()
 
 	td := harness.newDealBuilder(t, 1).withNoOpMinerStub().withBlockingHttpServer().build()
-	pi, err := td.ph.Provider.ExecuteDeal(td.params, peer.ID(""))
+	pi, err := td.ph.Provider.ExecuteDeal(context.Background(), td.params, peer.ID(""))
 	require.NoError(t, err)
 	require.False(t, pi.Accepted)
 	require.Contains(t, pi.Reason, "insufficient funds")
@@ -390,15 +390,73 @@ func TestDealRejectedForInsufficientProviderFunds(t *testing.T) {
 
 func TestDealRejectedForInsufficientProviderStorageSpace(t *testing.T) {
 	ctx := context.Background()
-	// setup the provider test harness with only 1 byte of storage
-	// space for incoming deals.
-	harness := NewHarness(t, withMaxStagingDealsBytes(1))
+	// setup the provider test harness with only enough storage
+	// space for 1.5 deals
+	fileSize := 2000
+	harness := NewHarness(t, withMaxStagingDealsBytes(uint64(fileSize*3)/2))
 	// start the provider test harness
 	harness.Start(t, ctx)
 	defer harness.Stop()
 
-	td := harness.newDealBuilder(t, 1).withNoOpMinerStub().withBlockingHttpServer().build()
-	pi, err := td.ph.Provider.ExecuteDeal(td.params, peer.ID(""))
+	// Make a deal
+	td := harness.newDealBuilder(t, 1, withNormalFileSize(fileSize)).withNoOpMinerStub().withBlockingHttpServer().build()
+	pi, err := td.ph.Provider.ExecuteDeal(context.Background(), td.params, peer.ID(""))
+	require.NoError(t, err)
+	require.True(t, pi.Accepted)
+
+	// Make a second deal - this one should fail because there is not enough
+	// space in the staging area for a second deal
+	td2 := harness.newDealBuilder(t, 2, withNormalFileSize(fileSize)).withNoOpMinerStub().withBlockingHttpServer().build()
+	pi, err = td2.ph.Provider.ExecuteDeal(context.Background(), td2.params, peer.ID(""))
+	require.NoError(t, err)
+	require.False(t, pi.Accepted)
+	require.Contains(t, pi.Reason, "no space left")
+}
+
+func TestDealRejectedForInsufficientProviderStorageSpacePerHost(t *testing.T) {
+	ctx := context.Background()
+	// Set up the harness such that
+	// - the download staging area is large enough for 10 deals
+	// - the portion of the staging area reserved for each host is 15%
+	//   (ie enough space for 1.5 deals)
+	// Therefore it should be possible to make several deals where the data
+	// for each deal is on a different host. But it should not be possible
+	// to make 2 deals where the data is on the same host.
+	fileSize := 2000
+	harness := NewHarness(t,
+		withMaxStagingDealsBytes(uint64(fileSize*10)),
+		withMaxStagingDealsPercentPerHost(15))
+	// start the provider test harness
+	harness.Start(t, ctx)
+	defer harness.Stop()
+
+	hostA := "http://1.2.3.4:1234"
+	hostB := "http://5.6.7.8:5678"
+	downloadUrl := func(h string) string {
+		return fmt.Sprintf(`{"URL":"%s/%d.car"}`, h, rand.Intn(2<<30))
+	}
+
+	// Make a deal with data url on host A
+	hostADeal := harness.newDealBuilder(t, 1, withNormalFileSize(fileSize)).withNoOpMinerStub().withBlockingHttpServer().build()
+	hostADeal.params.Transfer.Params = []byte(downloadUrl(hostA))
+	pi, err := hostADeal.ph.Provider.ExecuteDeal(ctx, hostADeal.params, "")
+	require.NoError(t, err)
+	require.True(t, pi.Accepted)
+
+	// Make a deal with data url on host B
+	hostBDeal := harness.newDealBuilder(t, 2, withNormalFileSize(fileSize)).withNoOpMinerStub().withBlockingHttpServer().build()
+	pi, err = hostBDeal.ph.Provider.ExecuteDeal(ctx, hostBDeal.params, "")
+	hostBDeal.params.Transfer.Params = []byte(downloadUrl(hostB))
+	require.NoError(t, err)
+	require.True(t, pi.Accepted)
+
+	// Make a second deal with data url on host A.
+	// This one should fail because we've already made a deal with
+	// data url on host A, and the download space per host is limited
+	// to 1.5 x the deal size.
+	hostADeal2 := harness.newDealBuilder(t, 3, withNormalFileSize(fileSize)).withNoOpMinerStub().withBlockingHttpServer().build()
+	hostADeal2.params.Transfer.Params = []byte(downloadUrl(hostA))
+	pi, err = hostADeal2.ph.Provider.ExecuteDeal(ctx, hostADeal2.params, "")
 	require.NoError(t, err)
 	require.False(t, pi.Accepted)
 	require.Contains(t, pi.Reason, "no space left")
@@ -423,6 +481,27 @@ func TestDealFailuresHandlingNonRecoverableErrors(t *testing.T) {
 				return tspt
 			}),
 		},
+	}, {
+		name:        "non-recoverable error when transport fails",
+		expectedErr: "data-transfer failed",
+		opts: []harnessOpt{
+			// Inject a Transport that returns success from Execute, but then
+			// returns an error from the transfer progress channel
+			withTransportBuilder(func(ctrl *gomock.Controller) transport.Transport {
+				th := mocks.NewMockHandler(ctrl)
+				evts := make(chan tspttypes.TransportEvent, 1)
+				evts <- tspttypes.TransportEvent{
+					NBytesReceived: 0,
+					Error:          errors.New("data-transfer failed"),
+				}
+				close(evts)
+				th.EXPECT().Sub().Return(evts)
+				th.EXPECT().Close()
+				tspt := mocks.NewMockTransport(ctrl)
+				tspt.EXPECT().Execute(gomock.Any(), gomock.Any(), gomock.Any()).Return(th, nil)
+				return tspt
+			}),
+		},
 	}, {
 		name:        "non-recoverable error when commp fails",
 		expectedErr: "failed to verify CommP",
@@ -570,18 +649,6 @@ func TestDealRestartAfterManualRecoverableErrors(t *testing.T) {
 		expectedErr string
 		onResume    func(builder *testDealBuilder) *testDeal
 	}{{
-		name: "transfer fails",
-		dbuilder: func(h *ProviderHarness) *testDeal {
-			// Simulate data transfer failure
-			return h.newDealBuilder(t, 1).withFailingHttpServer().build()
-		},
-		expectedErr: "data-transfer failed",
-		onResume: func(builder *testDealBuilder) *testDeal {
-			td := builder.withAllMinerCallsNonBlocking().build()
-			td.setTransferWorking(true)
-			return td
-		},
-	}, {
 		name: "publish fails",
 		dbuilder: func(h *ProviderHarness) *testDeal {
 			// Simulate publish deal failure
@@ -1113,20 +1180,21 @@ func (h *ProviderHarness) AssertDealDBState(t *testing.T, ctx context.Context, d
 }
 
 type ProviderHarness struct {
-	Host                   host.Host
-	GoMockCtrl             *gomock.Controller
-	TempDir                string
-	MinerAddr              address.Address
-	ClientAddr             address.Address
-	MockFullNode           *lotusmocks.MockFullNode
-	MinerStub              *smtestutil.MinerStub
-	DealsDB                *db.DealsDB
-	FundsDB                *db.FundsDB
-	StorageDB              *db.StorageDB
-	PublishWallet          address.Address
-	MinPublishFees         abi.TokenAmount
-	MaxStagingDealBytes    uint64
-	MockSealingPipelineAPI *mock_sealingpipeline.MockAPI
+	Host                         host.Host
+	GoMockCtrl                   *gomock.Controller
+	TempDir                      string
+	MinerAddr                    address.Address
+	ClientAddr                   address.Address
+	MockFullNode                 *lotusmocks.MockFullNode
+	MinerStub                    *smtestutil.MinerStub
+	DealsDB                      *db.DealsDB
+	FundsDB                      *db.FundsDB
+	StorageDB                    *db.StorageDB
+	PublishWallet                address.Address
+	MinPublishFees               abi.TokenAmount
+	MaxStagingDealBytes          uint64
+	MaxStagingDealPercentPerHost uint64
+	MockSealingPipelineAPI       *mock_sealingpipeline.MockAPI
 
 	Provider *Provider
 
@@ -1144,11 +1212,12 @@ type ProviderHarness struct {
 type providerConfig struct {
 	mockCtrl *gomock.Controller
 
-	maxStagingDealBytes  uint64
-	minPublishFees       abi.TokenAmount
-	disconnectAfterEvery int64
-	httpOpts             []httptransport.Option
-	transport            transport.Transport
+	maxStagingDealBytes          uint64
+	maxStagingDealPercentPerHost uint64
+	minPublishFees               abi.TokenAmount
+	disconnectAfterEvery         int64
+	httpOpts                     []httptransport.Option
+	transport                    transport.Transport
 
 	lockedFunds      big.Int
 	escrowFunds      big.Int
@@ -1197,6 +1266,12 @@ func withMaxStagingDealsBytes(max uint64) harnessOpt {
 	}
 }
 
+func withMaxStagingDealsPercentPerHost(max uint64) harnessOpt {
+	return func(pc *providerConfig) {
+		pc.maxStagingDealPercentPerHost = max
+	}
+}
+
 func withTransportBuilder(bldr func(controller *gomock.Controller) transport.Transport) harnessOpt {
 	return func(pc *providerConfig) {
 		pc.transport = bldr(pc.mockCtrl)
@@ -1315,15 +1390,16 @@ func NewHarness(t *testing.T, opts ...harnessOpt) *ProviderHarness {
 		DisconnectingServer: disconnServer,
 		Transport:           tspt,
 
-		MockSealingPipelineAPI: sps,
-		DealsDB:                dealsDB,
-		FundsDB:                db.NewFundsDB(sqldb),
-		StorageDB:              db.NewStorageDB(sqldb),
-		PublishWallet:          pw,
-		MinerStub:              minerStub,
-		MinPublishFees:         pc.minPublishFees,
-		MaxStagingDealBytes:    pc.maxStagingDealBytes,
-		SqlDB:                  sqldb,
+		MockSealingPipelineAPI:       sps,
+		DealsDB:                      dealsDB,
+		FundsDB:                      db.NewFundsDB(sqldb),
+		StorageDB:                    db.NewStorageDB(sqldb),
+		PublishWallet:                pw,
+		MinerStub:                    minerStub,
+		MinPublishFees:               pc.minPublishFees,
+		MaxStagingDealBytes:          pc.maxStagingDealBytes,
+		MaxStagingDealPercentPerHost: pc.maxStagingDealPercentPerHost,
+		SqlDB:                        sqldb,
 	}
 
 	// fund manager
@@ -1339,7 +1415,8 @@ func NewHarness(t *testing.T, opts ...harnessOpt) *ProviderHarness {
 	lr, err := fsRepo.Lock(repo.StorageMiner)
 	require.NoError(t, err)
 	smInitF := storagemanager.New(storagemanager.Config{
-		MaxStagingDealsBytes: ph.MaxStagingDealBytes,
+		MaxStagingDealsBytes:          ph.MaxStagingDealBytes,
+		MaxStagingDealsPercentPerHost: ph.MaxStagingDealPercentPerHost,
 	})
 	sm, err := smInitF(lr, sqldb)
 	require.NoError(t, err)
@@ -1356,7 +1433,15 @@ func NewHarness(t *testing.T, opts ...harnessOpt) *ProviderHarness {
 	askStore := &mockAskStore{}
 	askStore.SetAsk(pc.price, pc.verifiedPrice, pc.minPieceSize, pc.maxPieceSize)
 
-	prvCfg := Config{MaxTransferDuration: time.Hour, RemoteCommp: !pc.localCommp}
+	prvCfg := Config{
+		MaxTransferDuration: time.Hour,
+		RemoteCommp:         !pc.localCommp,
+		TransferLimiter: TransferLimiterConfig{
+			MaxConcurrent:    10,
+			StallCheckPeriod: time.Millisecond,
+			StallTimeout:     time.Hour,
+		},
+	}
 	prov, err := NewProvider(prvCfg, sqldb, dealsDB, fm, sm, fn, minerStub, minerAddr, minerStub, minerStub, sps, minerStub, df, sqldb,
 		logsDB, dagStore, ps, &NoOpIndexProvider{}, askStore, &mockSignatureVerifier{true, nil}, dl, tspt)
 	require.NoError(t, err)
@@ -1611,6 +1696,10 @@ func (ph *ProviderHarness) newDealBuilder(t *testing.T, seed int, opts ...dealPr
 	require.NoError(tbuilder.t, err)
 	name := carv2Fileinfo.Name()
 
+	req := tspttypes.HttpRequest{URL: "http://foo.bar"}
+	xferParams, err := json.Marshal(req)
+	require.NoError(t, err)
+
 	// assemble the final deal params to send to the provider
 	dealParams := &types.DealParams{
 		DealUUID:  uuid.New(),
@@ -1624,8 +1713,9 @@ func (ph *ProviderHarness) newDealBuilder(t *testing.T, seed int, opts ...dealPr
 		},
 		DealDataRoot: rootCid,
 		Transfer: types.Transfer{
-			Type: "http",
-			Size: uint64(carv2Fileinfo.Size()),
+			Type:   "http",
+			Params: xferParams,
+			Size:   uint64(carv2Fileinfo.Size()),
 		},
 	}
 
@@ -1737,12 +1827,6 @@ func (tbuilder *testDealBuilder) withAllMinerCallsBlocking() *testDealBuilder {
 	return tbuilder
 }
 
-func (tbuilder *testDealBuilder) withFailingHttpServer() *testDealBuilder {
-	tbuilder.setTransferParams(tbuilder.ph.NormalServer.URL)
-	tbuilder.ph.NormalServer.SetWorking(false)
-	return tbuilder
-}
-
 func (tbuilder *testDealBuilder) withBlockingHttpServer() *testDealBuilder {
 	tbuilder.ph.BlockingServer.AddFile(tbuilder.td.carv2FileName)
 	tbuilder.setTransferParams(tbuilder.td.ph.BlockingServer.URL)
@@ -1847,7 +1931,7 @@ type testDeal struct {
 }
 
 func (td *testDeal) executeAndSubscribeImportOfflineDeal() error {
-	pi, err := td.ph.Provider.ImportOfflineDealData(td.params.DealUUID, td.carv2FilePath)
+	pi, err := td.ph.Provider.ImportOfflineDealData(context.Background(), td.params.DealUUID, td.carv2FilePath)
 	if err != nil {
 		return err
 	}
@@ -1865,7 +1949,7 @@ func (td *testDeal) executeAndSubscribeImportOfflineDeal() error {
 }
 
 func (td *testDeal) executeAndSubscribe() error {
-	pi, err := td.ph.Provider.ExecuteDeal(td.params, "")
+	pi, err := td.ph.Provider.ExecuteDeal(context.Background(), td.params, "")
 	if err != nil {
 		return err
 	}
@@ -1988,10 +2072,6 @@ func (td *testDeal) unblockCommp() {
 	td.ph.MinerStub.UnblockCommp(td.params.DealUUID)
 }
 
-func (td *testDeal) setTransferWorking(working bool) {
-	td.ph.NormalServer.SetWorking(working)
-}
-
 func (td *testDeal) unblockPublish() {
 	td.ph.MinerStub.UnblockPublish(td.params.DealUUID)
 }
diff --git a/storagemarket/transfer_limiter.go b/storagemarket/transfer_limiter.go
new file mode 100644
index 000000000..e1709470f
--- /dev/null
+++ b/storagemarket/transfer_limiter.go
@@ -0,0 +1,344 @@
+package storagemarket
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"sync"
+	"time"
+
+	smtypes "github.com/filecoin-project/boost/storagemarket/types"
+	"github.com/google/uuid"
+)
+
+type transfer struct {
+	started   chan struct{}
+	deal      *smtypes.ProviderDealState
+	host      string
+	updatedAt time.Time
+	bytes     uint64
+}
+
+func (t *transfer) isStarted() bool {
+	select {
+	case <-t.started:
+		return true
+	default:
+		return false
+	}
+}
+
+type TransferLimiterConfig struct {
+	// The maximum number of concurrent transfers (soft limit - see comment below)
+	MaxConcurrent uint64
+	// The period between checking if a connection has stalled
+	StallCheckPeriod time.Duration
+	// The time that can elapse before a download is considered stalled
+	StallTimeout time.Duration
+}
+
+//
+// transferLimiter maintains a queue of transfers with a soft upper limit on
+// the number of concurrent transfers.
+//
+// To prevent slow or stalled transfers from blocking up the queue there are
+// a couple of mitigations:
+//
+// The queue is ordered such that we
+// - start transferring data for the oldest deal first
+// - prefer to start transfers with peers that don't have any ongoing transfer
+// - once the soft limit is reached, don't allow any new transfers with peers
+//   that have existing stalled transfers
+//
+// Note that peers are distinguished by their host (eg foo.bar:8080) not by
+// libp2p peer ID.
+//
+// For example, if there is
+// - one active transfer with peer A
+// - one pending transfer (peer A)
+// - one pending transfer (peer B)
+// the algorithm will prefer to start a transfer with peer B than peer A.
+//
+// This helps to ensure that slow peers don't block the transfer queue.
+//
+// The limit on the number of concurrent transfers is soft:
+// eg if there is a limit of 5 concurrent transfers and there are
+// - three active transfers
+// - two stalled transfers
+// then two more transfers are permitted to start (as long as they're not with
+// one of the stalled peers)
+//
+type transferLimiter struct {
+	cfg TransferLimiterConfig
+
+	lk    sync.RWMutex
+	xfers map[uuid.UUID]*transfer
+}
+
+func newTransferLimiter(cfg TransferLimiterConfig) (*transferLimiter, error) {
+	if cfg.MaxConcurrent == 0 {
+		return nil, fmt.Errorf("maximum active concurrent transfers must be > 0")
+	}
+	if cfg.StallCheckPeriod == 0 {
+		return nil, fmt.Errorf("transfer stall check period must be > 0")
+	}
+	if cfg.StallTimeout == 0 {
+		return nil, fmt.Errorf("transfer stall timeout must be > 0")
+	}
+
+	return &transferLimiter{
+		cfg:   cfg,
+		xfers: make(map[uuid.UUID]*transfer),
+	}, nil
+}
+
+func (tl *transferLimiter) run(ctx context.Context) {
+	// Periodically check for stalled transfers
+	ticker := time.NewTicker(tl.cfg.StallCheckPeriod)
+	defer ticker.Stop()
+
+	// Note: The first tick will occur after one stall check period (not
+	// immediately).
+	for {
+		select {
+		case t := <-ticker.C:
+			tl.check(t)
+
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (tl *transferLimiter) check(now time.Time) {
+	// Take a copy of the transfers map.
+	// We do this to avoid lock contention with the SetBytes message which
+	// is called with high frequency when there are a lot of concurrent
+	// transfers (every time data is received).
+	tl.lk.Lock()
+	xfers := make(map[uuid.UUID]*transfer, len(tl.xfers))
+	for id, xfer := range tl.xfers {
+		cp := *xfer
+		xfers[id] = &cp
+	}
+	tl.lk.Unlock()
+
+	// Count how many transfers are active (not stalled)
+	var activeCount uint64
+	transferringPeers := make(map[string]struct{}, len(xfers))
+	stalledPeers := make(map[string]struct{}, len(xfers))
+	unstartedXfers := make([]*transfer, 0, len(xfers))
+	for _, xfer := range xfers {
+		if !xfer.isStarted() {
+			// Build a list of unstarted transfers (needed later)
+			unstartedXfers = append(unstartedXfers, xfer)
+
+			// Skip transfers that haven't started
+			continue
+		}
+
+		// Build the set of peers that have an ongoing transfer (needed later)
+		transferringPeers[xfer.host] = struct{}{}
+
+		// Check each transfer to see if it has stalled
+		if now.Sub(xfer.updatedAt) < tl.cfg.StallTimeout {
+			activeCount++
+		} else {
+			stalledPeers[xfer.host] = struct{}{}
+		}
+	}
+
+	// Check if there are already enough active transfers
+	if activeCount >= tl.cfg.MaxConcurrent {
+		return
+	}
+
+	// Sort unstarted transfers by creation date (oldest first)
+	sort.Slice(unstartedXfers, func(i, j int) bool {
+		return unstartedXfers[i].deal.CreatedAt.Before(unstartedXfers[j].deal.CreatedAt)
+	})
+
+	// Gets the next transfer that should be started
+	nextTransfer := func() *transfer {
+		var next *transfer
+
+		// Iterate over unstarted transfers from oldest to newest
+		startedCount := tl.startedCount(xfers)
+		for _, xfer := range unstartedXfers {
+			// Skip transfers that have already been started.
+			// Note: A previous call to nextTransfer may have started the
+			// transfer.
+			if xfer.isStarted() {
+				continue
+			}
+
+			// If there is already a transfer to the same peer and it's stalled,
+			// allow a new transfer with that peer, but only up to the soft
+			// limit
+			_, isStalledPeer := stalledPeers[xfer.host]
+			if isStalledPeer && startedCount >= tl.cfg.MaxConcurrent {
+				continue
+			}
+
+			// Default to choosing the oldest unstarted transfer
+			if next == nil {
+				next = xfer
+			}
+
+			// If there are no transfers with the peer that sent the storage deal,
+			// start a transfer.
+			// This helps ensure that a slow peer doesn't block up the transfer
+			// queue, because we'll favour opening a transfer to a new peer
+			// over a peer that already has a transfer (which may be slow).
+			if _, ok := transferringPeers[xfer.host]; !ok {
+				return xfer
+			}
+		}
+
+		return next
+	}
+
+	// Start new transfers until we reach the limit
+	for i := activeCount; i < tl.cfg.MaxConcurrent; i++ {
+		next := nextTransfer()
+		if next == nil {
+			return
+		}
+
+		// Update the list of peers with active transfers
+		transferringPeers[next.host] = struct{}{}
+
+		// Signal that the transfer has started
+		next.updatedAt = time.Now()
+		close(next.started)
+	}
+}
+
+// Count how many transfers have been started but not completed
+func (tl *transferLimiter) startedCount(xfers map[uuid.UUID]*transfer) uint64 {
+	var count uint64
+	for _, xfer := range xfers {
+		if xfer.isStarted() {
+			count++
+		}
+	}
+	return count
+}
+
+// Count how many transfers there are in total
+func (tl *transferLimiter) transfersCount() int {
+	tl.lk.RLock()
+	defer tl.lk.RUnlock()
+
+	return len(tl.xfers)
+}
+
+// Wait for the next open spot in the transfer queue
+func (tl *transferLimiter) waitInQueue(ctx context.Context, deal *smtypes.ProviderDealState) error {
+	host, err := deal.Transfer.Host()
+	if err != nil {
+		return fmt.Errorf("getting host from Transfer params for deal %s: %w", deal.DealUuid, err)
+	}
+	xfer := &transfer{
+		deal:    deal,
+		host:    host,
+		started: make(chan struct{}),
+	}
+
+	// Add the transfer to the queue
+	tl.lk.Lock()
+	tl.xfers[deal.DealUuid] = xfer
+	tl.lk.Unlock()
+
+	// Wait for the signal that the transfer can start
+	select {
+	case <-xfer.started:
+		return nil
+	case <-ctx.Done():
+		tl.complete(deal.DealUuid)
+		return ctx.Err()
+	}
+}
+
+// Called when a transfer has completed (or errored out)
+func (tl *transferLimiter) complete(dealUuid uuid.UUID) {
+	tl.lk.Lock()
+	defer tl.lk.Unlock()
+
+	delete(tl.xfers, dealUuid)
+}
+
+// Called each time the transfer progresses
+func (tl *transferLimiter) setBytes(dealUuid uuid.UUID, bytes uint64) {
+	tl.lk.Lock()
+	defer tl.lk.Unlock()
+
+	xfer, ok := tl.xfers[dealUuid]
+	if ok {
+		xfer.updatedAt = time.Now()
+		xfer.bytes = bytes
+	}
+}
+
+func (tl *transferLimiter) isStalled(dealUuid uuid.UUID) bool {
+	now := time.Now()
+
+	tl.lk.RLock()
+	defer tl.lk.RUnlock()
+
+	xfer, ok := tl.xfers[dealUuid]
+	if !ok {
+		return false
+	}
+
+	if !xfer.isStarted() {
+		return false
+	}
+
+	return now.Sub(xfer.updatedAt) >= tl.cfg.StallTimeout
+}
+
+type HostTransferStats struct {
+	Host      string
+	Total     int
+	Started   int
+	Stalled   int
+	DealUuids []uuid.UUID
+}
+
+func (tl *transferLimiter) stats() []*HostTransferStats {
+	now := time.Now()
+
+	tl.lk.RLock()
+	defer tl.lk.RUnlock()
+
+	// Count the number of transfers, started and stalled per host
+	stats := make(map[string]*HostTransferStats)
+	for _, xfer := range tl.xfers {
+		hostStats, ok := stats[xfer.host]
+		if !ok {
+			hostStats = &HostTransferStats{Host: xfer.host}
+			stats[xfer.host] = hostStats
+		}
+
+		hostStats.Total++
+		hostStats.DealUuids = append(hostStats.DealUuids, xfer.deal.DealUuid)
+		if !xfer.isStarted() {
+			continue
+		}
+		hostStats.Started++
+		if now.Sub(xfer.updatedAt) >= tl.cfg.StallTimeout {
+			hostStats.Stalled++
+		}
+	}
+
+	// Sort the stats by host
+	statsArr := make([]*HostTransferStats, 0, len(stats))
+	for _, s := range stats {
+		statsArr = append(statsArr, s)
+	}
+	sort.Slice(statsArr, func(i, j int) bool {
+		return statsArr[i].Host < statsArr[j].Host
+	})
+	return statsArr
+}
diff --git a/storagemarket/transfer_limiter_test.go b/storagemarket/transfer_limiter_test.go
new file mode 100644
index 000000000..534ae913c
--- /dev/null
+++ b/storagemarket/transfer_limiter_test.go
@@ -0,0 +1,381 @@
+package storagemarket
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"golang.org/x/exp/rand"
+	"testing"
+	"time"
+
+	smtypes "github.com/filecoin-project/boost/storagemarket/types"
+	"github.com/filecoin-project/boost/testutil"
+	"github.com/filecoin-project/boost/transport/types"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+)
+
+func generateDeal() *smtypes.ProviderDealState {
+	return generateDealWithHost(fmt.Sprintf("foo.bar:%d", rand.Uint64()))
+}
+
+func generateDealWithHost(host string) *smtypes.ProviderDealState {
+	transferParams := types.HttpRequest{
+		URL: fmt.Sprintf("http://%s/piece/%s", host, uuid.New()),
+	}
+	json, err := json.Marshal(transferParams)
+	if err != nil {
+		panic(err)
+	}
+	return &smtypes.ProviderDealState{
+		DealUuid:  uuid.New(),
+		CreatedAt: time.Now(),
+		Transfer: smtypes.Transfer{
+			Type:   "http",
+			Params: json,
+		},
+	}
+}
+
+func TestTransferLimiterBasic(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	// Set up the transfer limiter
+	tl, err := newTransferLimiter(TransferLimiterConfig{
+		MaxConcurrent:    1,
+		StallCheckPeriod: time.Millisecond,
+		StallTimeout:     30 * time.Second,
+	})
+	require.NoError(t, err)
+
+	go tl.run(ctx)
+
+	// Add a deal to the transfer queue
+	deal1 := generateDeal()
+	err = tl.waitInQueue(ctx, deal1)
+	require.NoError(t, err)
+
+	// Remove the deal from the transfer queue
+	tl.complete(deal1.DealUuid)
+}
+
+// Verifies that a new transfer is blocked until the number of ongoing
+// transfers falls below the limit
+func TestTransferLimiterQueueSize(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	tl, err := newTransferLimiter(TransferLimiterConfig{
+		MaxConcurrent:    1,
+		StallCheckPeriod: time.Millisecond,
+		StallTimeout:     30 * time.Second,
+	})
+	require.NoError(t, err)
+
+	// Generate two deals and add them to the transfer queue
+	deal1 := generateDeal()
+	deal2 := generateDeal()
+
+	started := make(chan struct{}, 2)
+	go func() {
+		err := tl.waitInQueue(ctx, deal1)
+		require.NoError(t, err)
+		started <- struct{}{}
+	}()
+
+	go func() {
+		err := tl.waitInQueue(ctx, deal2)
+		require.NoError(t, err)
+		started <- struct{}{}
+	}()
+
+	// Wait till both go-routines call waitInQueue
+	require.Eventually(t, func() bool { return tl.transfersCount() == 2 }, time.Second, time.Millisecond)
+
+	// Expect the first transfer to start
+	tl.check(time.Now())
+	<-started
+
+	// Expect the second transfer not to start yet, because the transfer queue
+	// has a limit of 1
+	select {
+	case <-started:
+		require.Fail(t, "expected second transfer not to start yet")
+	default:
+	}
+
+	// Complete the first transfer
+	tl.complete(deal1.DealUuid)
+
+	// Expect the second transfer to start now that the first has completed
+	tl.check(time.Now())
+	<-started
+}
+
+// Verifies that if a transfer stalls, another transfer is allowed to start,
+// even if that means the total number of transfers breaks the soft limit
+func TestTransferLimiterStalledTransfer(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	cfg := TransferLimiterConfig{
+		MaxConcurrent:    1,
+		StallCheckPeriod: time.Millisecond,
+		StallTimeout:     time.Second,
+	}
+	tl, err := newTransferLimiter(cfg)
+	require.NoError(t, err)
+
+	// Generate two deals and add them to the transfer queue
+	deal1 := generateDeal()
+	deal2 := generateDeal()
+
+	started := make(chan struct{}, 2)
+	go func() {
+		err := tl.waitInQueue(ctx, deal1)
+		require.NoError(t, err)
+		started <- struct{}{}
+	}()
+
+	go func() {
+		err := tl.waitInQueue(ctx, deal2)
+		require.NoError(t, err)
+		started <- struct{}{}
+	}()
+
+	// Wait till both go-routines call waitInQueue
+	require.Eventually(t, func() bool { return tl.transfersCount() == 2 }, time.Second, time.Millisecond)
+
+	// Expect the first transfer to start
+	tl.check(time.Now())
+	<-started
+
+	// Expect the second transfer not to start yet, because the transfer queue
+	// has a limit of 1
+	select {
+	case <-started:
+		require.Fail(t, "expected second transfer not to start yet")
+	default:
+	}
+
+	// Tell the transfer limiter that some progress has been made in the
+	// transfer for deal 1
+	tl.setBytes(deal1.DealUuid, 1)
+
+	// Simulate a check after half of the stall timeout has elapsed
+	tl.check(time.Now().Add(cfg.StallTimeout / 2))
+
+	// Expect the second transfer not to start yet, because the stall timeout
+	// has not expired
+	select {
+	case <-started:
+		require.Fail(t, "expected second transfer not to start yet")
+	default:
+	}
+
+	// Once the stall duration has elapsed with no updates to the first
+	// transfer, expect the second transfer to be allowed to start
+	tl.check(time.Now().Add(cfg.StallTimeout))
+	<-started
+}
+
+// Verifies that transfers are prioritized in order from oldest to newest
+func TestTransferLimiterPriorityOldestFirst(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	cfg := TransferLimiterConfig{
+		MaxConcurrent:    1,
+		StallCheckPeriod: time.Millisecond,
+		StallTimeout:     30 * time.Second,
+	}
+	tl, err := newTransferLimiter(cfg)
+	require.NoError(t, err)
+
+	// Generate deals and add them to the transfer queue in the reverse order
+	// than they were generated
+	dealCount := 100
+	deals := make([]*smtypes.ProviderDealState, 0, dealCount)
+	for i := 0; i < dealCount; i++ {
+		dl := generateDeal()
+		dl.CreatedAt = time.Now().Add(-time.Hour).Round(time.Minute).Add(time.Duration(i) * time.Second)
+		deals = append(deals, dl)
+	}
+	dealsReversed := make(chan *smtypes.ProviderDealState, len(deals))
+	for i := len(deals) - 1; i >= 0; i-- {
+		dealsReversed <- deals[i]
+	}
+
+	started := make(chan *smtypes.ProviderDealState)
+	for i := 0; i < len(deals); i++ {
+		// The order in which the go routines run is non-deterministic,
+		// but by adding deals in newest-to-oldest order, we can assume that
+		// it's extremely unlikely the deals will be started in
+		// oldest-to-newest order
+		go func() {
+			dl := <-dealsReversed
+			err := tl.waitInQueue(ctx, dl)
+			require.NoError(t, err)
+			started <- dl
+		}()
+	}
+
+	// Wait for all the deals to be added to the transfer queue
+	require.Eventually(t, func() bool { return tl.transfersCount() == dealCount }, time.Second, time.Millisecond)
+
+	// Expect the deals to be started in order from oldest to newest
+	for i := 0; i < len(deals); i++ {
+		go tl.check(time.Now())
+
+		dl := <-started
+		require.Equal(t, deals[i].DealUuid, dl.DealUuid)
+
+		// Make space in the queue for the next deal to be started
+		tl.complete(dl.DealUuid)
+	}
+}
+
+// Verifies that the prioritization favours transfers to peers that don't
+// already have an ongoing transfer.
+// eg there is
+// - an ongoing transfer to peer A
+// - a queued transfer to peer A
+// - a queued transfer to peer B
+// The next transfer should be the one to peer B
+func TestTransferLimiterPriorityNoExistingTransferToPeerFirst(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	cfg := TransferLimiterConfig{
+		MaxConcurrent:    2,
+		StallCheckPeriod: time.Millisecond,
+		StallTimeout:     30 * time.Second,
+	}
+	tl, err := newTransferLimiter(cfg)
+	require.NoError(t, err)
+
+	// Generate three deals, where the first two have the same peer
+	p := testutil.GeneratePeer()
+	h := "myhost.com"
+	deal1 := generateDealWithHost(h)
+	deal1.ClientPeerID = p
+	deal2 := generateDealWithHost(h)
+	deal2.ClientPeerID = p
+	deal3 := generateDeal()
+
+	deals := make(chan *smtypes.ProviderDealState, 3)
+	deals <- deal1
+	deals <- deal2
+	deals <- deal3
+
+	started := make(chan *smtypes.ProviderDealState, len(deals))
+	for i := 0; i < 3; i++ {
+		go func() {
+			dl := <-deals
+			err := tl.waitInQueue(ctx, dl)
+			require.NoError(t, err)
+			started <- dl
+		}()
+	}
+
+	// Wait for all the deals to be added to the transfer queue
+	require.Eventually(t, func() bool { return len(deals) == 0 }, time.Second, time.Millisecond)
+
+	// The queue size limit is 2.
+	// The oldest to newest order is deal1, deal2, deal3
+	// However we expect deal1 and deal3 to be started first.
+	// This is because deal1 and deal2 have the same peer ID, and
+	// the algorithm should favour deal3 because it has a different
+	// peer ID.
+	tl.check(time.Now())
+	dl := <-started
+	require.True(t, dl.DealUuid == deal1.DealUuid || dl.DealUuid == deal3.DealUuid)
+	dl = <-started
+	require.True(t, dl.DealUuid == deal1.DealUuid || dl.DealUuid == deal3.DealUuid)
+
+	// Complete the first deal transfer to make space for another transfer
+	tl.complete(deal1.DealUuid)
+
+	// Expect deal2 to start last
+	tl.check(time.Now())
+	dl = <-started
+	require.Equal(t, deal2.DealUuid, dl.DealUuid)
+}
+
+// Verifies that a new transfer will not be started if there are already
+// transfers to that same peer that are stalled, and the soft limit has
+// been reached
+func TestTransferLimiterStalledTransferHardLimited(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	cfg := TransferLimiterConfig{
+		MaxConcurrent:    2,
+		StallCheckPeriod: time.Millisecond,
+		StallTimeout:     time.Second,
+	}
+	tl, err := newTransferLimiter(cfg)
+	require.NoError(t, err)
+
+	// Generate a deal and add to the transfer queue
+	h := "myhost.com"
+	deal1 := generateDealWithHost(h)
+
+	started := make(chan struct{}, 3)
+	go func() {
+		err := tl.waitInQueue(ctx, deal1)
+		require.NoError(t, err)
+		started <- struct{}{}
+	}()
+
+	// Wait till go-routine calls waitInQueue
+	require.Eventually(t, func() bool { return tl.transfersCount() == 1 }, time.Second, time.Millisecond)
+
+	// Expect the first transfer to start
+	tl.check(time.Now())
+	<-started
+
+	// Mark the first transfer as stalled
+	tl.check(time.Now().Add(cfg.StallTimeout))
+
+	// Generate a second deal to the same peer
+	deal2 := generateDealWithHost(h)
+	deal2.ClientPeerID = deal1.ClientPeerID
+
+	go func() {
+		err := tl.waitInQueue(ctx, deal2)
+		require.NoError(t, err)
+		started <- struct{}{}
+	}()
+
+	// Wait till go-routine calls waitInQueue
+	require.Eventually(t, func() bool { return tl.transfersCount() == 2 }, time.Second, time.Millisecond)
+
+	// It should be allowed to start, because even though there's a stalled
+	// transfer to the peer, we're still below the soft limit
+	tl.check(time.Now().Add(cfg.StallTimeout))
+	<-started
+
+	// Generate a third deal to the same peer
+	deal3 := generateDealWithHost(h)
+	deal3.ClientPeerID = deal1.ClientPeerID
+
+	go func() {
+		tl.waitInQueue(ctx, deal3) //nolint:errcheck
+		started <- struct{}{}
+	}()
+
+	// Wait till go-routine calls waitInQueue
+	require.Eventually(t, func() bool { return tl.transfersCount() == 3 }, time.Second, time.Millisecond)
+
+	tl.check(time.Now().Add(cfg.StallTimeout))
+
+	// Expect the third transfer not to start yet, because there's a stalled
+	// transfer to the same peer in the queue and we've reached the soft limit
+	select {
+	case <-started:
+		require.Fail(t, "expected third transfer not to start yet")
+	default:
+	}
+}
diff --git a/storagemarket/transfers.go b/storagemarket/transfers.go
index f23715cd1..e1d3fe0c9 100644
--- a/storagemarket/transfers.go
+++ b/storagemarket/transfers.go
@@ -8,16 +8,11 @@ import (
 	"github.com/google/uuid"
 )
 
-// Keep up to 60s of samples
+// Keep up to 20s of samples
 const maxSamples = 20
 
-// Transfers returns a map of active transfers, sampled for up to 60s
-func (p *Provider) Transfers() map[uuid.UUID][]transferPoint {
-	return p.transfers.transfers()
-}
-
 // A sample of the number of bytes transferred at the given time
-type transferPoint struct {
+type TransferPoint struct {
 	// The time at which the sample was taken, truncated to the nearest second
 	At time.Time
 	// The number of bytes transferred
@@ -29,7 +24,7 @@ type dealTransfers struct {
 	// maps from deal UUID -> samples of the number of bytes transferred in
 	// the last 60 seconds
 	samplesLk sync.RWMutex
-	samples   map[uuid.UUID][]transferPoint
+	samples   map[uuid.UUID][]TransferPoint
 
 	// Maps from active transfer deal UUID to number of bytes transferred
 	activeLk sync.RWMutex
@@ -38,7 +33,7 @@ type dealTransfers struct {
 
 func newDealTransfers() *dealTransfers {
 	return &dealTransfers{
-		samples: make(map[uuid.UUID][]transferPoint),
+		samples: make(map[uuid.UUID][]TransferPoint),
 		active:  make(map[uuid.UUID]uint64),
 	}
 }
@@ -77,11 +72,11 @@ func (dt *dealTransfers) sample(now time.Time) {
 		// Get the array of samples
 		points, ok := dt.samples[dealUUID]
 		if !ok {
-			points = []transferPoint{}
+			points = []TransferPoint{}
 		}
 
 		// Add a point for the current second
-		point := transferPoint{
+		point := TransferPoint{
 			At:    now,
 			Bytes: bytes,
 		}
@@ -91,7 +86,7 @@ func (dt *dealTransfers) sample(now time.Time) {
 		if len(points) > maxSamples {
 			// We need to make a copy of the array to avoid leaking memory.
 			// It may be worth using a ring-buffer if this is too slow.
-			newPoints := make([]transferPoint, maxSamples)
+			newPoints := make([]TransferPoint, maxSamples)
 			copy(newPoints, points[len(points)-maxSamples:])
 			points = newPoints
 		}
@@ -109,14 +104,14 @@ func (dt *dealTransfers) sample(now time.Time) {
 
 		// Add a point for non-active samples, with the same transferred bytes
 		// as the previous point
-		points = append(points, transferPoint{
+		points = append(points, TransferPoint{
 			At:    now,
 			Bytes: points[len(points)-1].Bytes,
 		})
 
 		// If the maximum number of samples has been reached
 		if len(points) > maxSamples {
-			// If the transfer has been inactive for 60s, delete the samples
+			// If the transfer has been inactive for 20s, delete the samples
 			if points[0].Bytes == points[len(points)-1].Bytes {
 				delete(dt.samples, dealUUID)
 				continue
@@ -130,19 +125,32 @@ func (dt *dealTransfers) sample(now time.Time) {
 	}
 }
 
-func (dt *dealTransfers) transfers() map[uuid.UUID][]transferPoint {
+func (dt *dealTransfers) transfers() map[uuid.UUID][]TransferPoint {
 	dt.samplesLk.RLock()
 	defer dt.samplesLk.RUnlock()
 
-	deals := make(map[uuid.UUID][]transferPoint, len(dt.samples))
+	deals := make(map[uuid.UUID][]TransferPoint, len(dt.samples))
 	for dealUUID, points := range dt.samples {
-		pts := make([]transferPoint, len(points))
+		pts := make([]TransferPoint, len(points))
 		copy(pts, points)
 		deals[dealUUID] = pts
 	}
 	return deals
 }
 
+func (dt *dealTransfers) transfer(dealUUID uuid.UUID) []TransferPoint {
+	dt.samplesLk.RLock()
+	defer dt.samplesLk.RUnlock()
+
+	points, ok := dt.samples[dealUUID]
+	if !ok {
+		return nil
+	}
+	pts := make([]TransferPoint, len(points))
+	copy(pts, points)
+	return pts
+}
+
 func (dt *dealTransfers) setBytes(dealUUID uuid.UUID, bytes uint64) {
 	dt.activeLk.Lock()
 	defer dt.activeLk.Unlock()
@@ -163,3 +171,28 @@ func (dt *dealTransfers) complete(dealUUID uuid.UUID) {
 
 	delete(dt.active, dealUUID)
 }
+
+// Transfers returns a map of active transfers, sampled for up to 20s
+func (p *Provider) Transfers() map[uuid.UUID][]TransferPoint {
+	return p.transfers.transfers()
+}
+
+// Transfer returns samples of an active transfer, sampled for up to 20s
+func (p *Provider) Transfer(dealUuid uuid.UUID) []TransferPoint {
+	return p.transfers.transfer(dealUuid)
+}
+
+// Get the number of bytes downloaded in total for the given deal
+func (p *Provider) NBytesReceived(dealUuid uuid.UUID) uint64 {
+	return p.transfers.getBytes(dealUuid)
+}
+
+// Indicates if a transfer has been marked as "stalled", ie the transfer is
+// not making any progress
+func (p *Provider) IsTransferStalled(dealUuid uuid.UUID) bool {
+	return p.xferLimiter.isStalled(dealUuid)
+}
+
+func (p *Provider) TransferStats() []*HostTransferStats {
+	return p.xferLimiter.stats()
+}
diff --git a/storagemarket/types/types.go b/storagemarket/types/types.go
index f59acb30b..28972f219 100644
--- a/storagemarket/types/types.go
+++ b/storagemarket/types/types.go
@@ -2,12 +2,18 @@ package types
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"io"
+	"net/url"
 
 	"github.com/filecoin-project/boost/sealingpipeline"
+	"github.com/filecoin-project/boost/transport/httptransport/util"
+	"github.com/filecoin-project/boost/transport/types"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-fil-markets/shared"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	multiaddrutil "github.com/filecoin-project/go-legs/httpsync/multiaddr"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/builtin/v8/market"
 	"github.com/filecoin-project/go-state-types/crypto"
@@ -97,6 +103,42 @@ type Transfer struct {
 	Size uint64
 }
 
+func (t *Transfer) Host() (string, error) {
+	if t.Type != "http" && t.Type != "libp2p" {
+		return "", fmt.Errorf("cannot parse params for unrecognized transfer type '%s'", t.Type)
+	}
+
+	// de-serialize transport opaque token
+	tInfo := &types.HttpRequest{}
+	if err := json.Unmarshal(t.Params, tInfo); err != nil {
+		return "", fmt.Errorf("failed to de-serialize transport params bytes '%s': %w", string(t.Params), err)
+	}
+
+	// Parse http / multiaddr url
+	u, err := util.ParseUrl(tInfo.URL)
+	if err != nil {
+		return "", fmt.Errorf("cannot parse url '%s': %w", tInfo.URL, err)
+	}
+
+	// If the url is in libp2p format
+	if u.Scheme == util.Libp2pScheme {
+		// Get the host from the multiaddr
+		mahttp, err := multiaddrutil.ToURL(u.Multiaddr)
+		if err != nil {
+			return "", err
+		}
+		return mahttp.Host, nil
+	}
+
+	// Otherwise parse as an http url
+	httpUrl, err := url.Parse(u.Url)
+	if err != nil {
+		return "", fmt.Errorf("cannot parse url '%s' from '%s': %w", u.Url, tInfo.URL, err)
+	}
+
+	return httpUrl.Host, nil
+}
+
 type DealResponse struct {
 	Accepted bool
 	// Message is the reason the deal proposal was rejected. It is empty if
diff --git a/storagemarket/types/types_test.go b/storagemarket/types/types_test.go
new file mode 100644
index 000000000..4ecfc223f
--- /dev/null
+++ b/storagemarket/types/types_test.go
@@ -0,0 +1,49 @@
+package types
+
+import (
+	"encoding/json"
+	"github.com/filecoin-project/boost/transport/types"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestTransferHost(t *testing.T) {
+	testCases := []struct {
+		name     string
+		xferType string
+		url      string
+		expected string
+	}{{
+		name:     "http",
+		xferType: "http",
+		url:      "http://foo.bar:1234",
+		expected: "foo.bar:1234",
+	}, {
+		name:     "libp2p http",
+		xferType: "libp2p",
+		url:      "libp2p:///ip4/1.2.3.4/tcp/5678/p2p/Qma9T5YraSnpRDZqRR4krcSJabThc8nwZuJV3LercPHufi",
+		expected: "1.2.3.4:5678",
+	}, {
+		name:     "libp2p quic",
+		xferType: "libp2p",
+		url:      "libp2p:///ip4/1.2.3.4/udp/5678/quic/p2p/Qma9T5YraSnpRDZqRR4krcSJabThc8nwZuJV3LercPHufi",
+		expected: "1.2.3.4:5678",
+	}}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			req := types.HttpRequest{URL: tc.url}
+			res, err := json.Marshal(req)
+			require.NoError(t, err)
+
+			xfer := Transfer{
+				Type:   tc.xferType,
+				Params: res,
+			}
+			h, err := xfer.Host()
+			require.NoError(t, err)
+
+			require.Equal(t, tc.expected, h)
+		})
+	}
+}
diff --git a/tracing/exporter.go b/tracing/exporter.go
new file mode 100644
index 000000000..13b00ce1e
--- /dev/null
+++ b/tracing/exporter.go
@@ -0,0 +1,53 @@
+package tracing
+
+import (
+	"context"
+
+	octrace "go.opencensus.io/trace"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/bridge/opencensus"
+	"go.opentelemetry.io/otel/exporters/jaeger"
+	"go.opentelemetry.io/otel/sdk/resource"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
+)
+
+// Registers a Tracer provider globally and returns it's shutdown function
+func New(service, endpoint string) (func(context.Context) error, error) {
+	provider, err := tracerProvider(endpoint, service)
+	if err != nil {
+		return nil, err
+	}
+
+	// Sets the global Tracer provider
+	otel.SetTracerProvider(provider)
+
+	// Opencensus bridge so that older OC spans are compatible with OT
+	// This is specifically to support capturing traces in contexts provided to go-jsonrpc,
+	// as it creates spans with OC instead of OT
+	octrace.DefaultTracer = opencensus.NewTracer(Tracer)
+
+	return provider.Shutdown, nil
+}
+
+// tracerProvider returns an OpenTelemetry TracerProvider configured to use
+// the Jaeger exporter that will send spans to the provided url. The returned
+// TracerProvider will also use a Resource configured with all the information
+// about the application.
+func tracerProvider(url, service string) (*sdktrace.TracerProvider, error) {
+	// Create the Jaeger exporter
+	exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
+	if err != nil {
+		return nil, err
+	}
+	tp := sdktrace.NewTracerProvider(
+		// Always be sure to batch in production.
+		sdktrace.WithBatcher(exp),
+		// Record information about this application in a Resource.
+		sdktrace.WithResource(resource.NewWithAttributes(
+			semconv.SchemaURL,
+			semconv.ServiceNameKey.String(service),
+		)),
+	)
+	return tp, nil
+}
diff --git a/tracing/tracing.go b/tracing/tracing.go
new file mode 100644
index 000000000..e926143ac
--- /dev/null
+++ b/tracing/tracing.go
@@ -0,0 +1,20 @@
+package tracing
+
+import (
+	"go.opentelemetry.io/otel"
+	semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
+	trace "go.opentelemetry.io/otel/trace"
+)
+
+const (
+	tracerName = "github.com/filecoin-project/boost"
+)
+
+var (
+	Tracer = otel.GetTracerProvider().Tracer(
+		tracerName,
+		trace.WithSchemaURL(semconv.SchemaURL),
+	)
+)
+
+type Tracing struct{}
diff --git a/transport/httptransport/http_transport.go b/transport/httptransport/http_transport.go
index 7f9c69663..02529ccd0 100644
--- a/transport/httptransport/http_transport.go
+++ b/transport/httptransport/http_transport.go
@@ -12,8 +12,8 @@ import (
 	"time"
 
 	"github.com/filecoin-project/boost/storagemarket/logs"
-
 	"github.com/filecoin-project/boost/transport"
+	"github.com/filecoin-project/boost/transport/httptransport/util"
 	"github.com/filecoin-project/boost/transport/types"
 	"github.com/google/uuid"
 	"github.com/jpillora/backoff"
@@ -30,10 +30,13 @@ const (
 	maxBackOff           = 10 * time.Minute
 	factor               = 1.5
 	maxReconnectAttempts = 15
-
-	libp2pScheme = "libp2p"
 )
 
+type httpError struct {
+	error
+	code int
+}
+
 var _ transport.Transport = (*httpTransport)(nil)
 
 type Option func(*httpTransport)
@@ -98,11 +101,11 @@ func (h *httpTransport) Execute(ctx context.Context, transportInfo []byte, dealI
 	}
 
 	// parse request URL
-	u, err := parseUrl(tInfo.URL)
+	u, err := util.ParseUrl(tInfo.URL)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse request url: %w", err)
 	}
-	tInfo.URL = u.url
+	tInfo.URL = u.Url
 
 	// check that the outputFile exists
 	fi, err := os.Stat(dealInfo.OutputFile)
@@ -146,8 +149,8 @@ func (h *httpTransport) Execute(ctx context.Context, transportInfo []byte, dealI
 	}
 
 	// If this is a libp2p URL
-	if u.scheme == libp2pScheme {
-		h.dl.Infow(duuid, "libp2p-http url", "url", tInfo.URL, "peer id", u.peerID, "multiaddr", u.multiaddr)
+	if u.Scheme == util.Libp2pScheme {
+		h.dl.Infow(duuid, "libp2p-http url", "url", tInfo.URL, "peer id", u.PeerID, "multiaddr", u.Multiaddr)
 
 		// Use the libp2p client
 		t.client = h.libp2pClient
@@ -157,13 +160,13 @@ func (h *httpTransport) Execute(ctx context.Context, transportInfo []byte, dealI
 		if deadline, ok := ctx.Deadline(); ok {
 			addrTtl = time.Until(deadline)
 		}
-		h.libp2pHost.Peerstore().AddAddr(u.peerID, u.multiaddr, addrTtl)
+		h.libp2pHost.Peerstore().AddAddr(u.PeerID, u.Multiaddr, addrTtl)
 
 		// Protect the connection for the lifetime of the data transfer
 		tag := uuid.New().String()
-		h.libp2pHost.ConnManager().Protect(u.peerID, tag)
+		h.libp2pHost.ConnManager().Protect(u.PeerID, tag)
 		cleanupFns = append(cleanupFns, func() {
-			h.libp2pHost.ConnManager().Unprotect(u.peerID, tag)
+			h.libp2pHost.ConnManager().Unprotect(u.PeerID, tag)
 		})
 	} else {
 		t.client = http.DefaultClient
diff --git a/transport/httptransport/util.go b/transport/httptransport/util/util.go
similarity index 60%
rename from transport/httptransport/util.go
rename to transport/httptransport/util/util.go
index f48f4fbbd..db7b813df 100644
--- a/transport/httptransport/util.go
+++ b/transport/httptransport/util/util.go
@@ -1,4 +1,4 @@
-package httptransport
+package util
 
 import (
 	"fmt"
@@ -9,19 +9,16 @@ import (
 	"github.com/multiformats/go-multiaddr"
 )
 
-type httpError struct {
-	error
-	code int
-}
+const Libp2pScheme = "libp2p"
 
-type transportUrl struct {
-	scheme    string
-	url       string
-	peerID    peer.ID
-	multiaddr multiaddr.Multiaddr
+type TransportUrl struct {
+	Scheme    string
+	Url       string
+	PeerID    peer.ID
+	Multiaddr multiaddr.Multiaddr
 }
 
-func parseUrl(urlStr string) (*transportUrl, error) {
+func ParseUrl(urlStr string) (*TransportUrl, error) {
 	u, err := url.Parse(urlStr)
 	if err != nil {
 		return nil, fmt.Errorf("parsing url '%s': %w", urlStr, err)
@@ -29,15 +26,15 @@ func parseUrl(urlStr string) (*transportUrl, error) {
 	if u.Scheme == "" {
 		return nil, fmt.Errorf("parsing url '%s': could not parse scheme", urlStr)
 	}
-	if u.Scheme == libp2pScheme {
+	if u.Scheme == Libp2pScheme {
 		return parseLibp2pUrl(urlStr)
 	}
-	return &transportUrl{scheme: u.Scheme, url: urlStr}, nil
+	return &TransportUrl{Scheme: u.Scheme, Url: urlStr}, nil
 }
 
-func parseLibp2pUrl(urlStr string) (*transportUrl, error) {
+func parseLibp2pUrl(urlStr string) (*TransportUrl, error) {
 	// Remove libp2p prefix
-	prefix := libp2pScheme + "://"
+	prefix := Libp2pScheme + "://"
 	if !strings.HasPrefix(urlStr, prefix) {
 		return nil, fmt.Errorf("libp2p URL '%s' must start with prefix '%s'", urlStr, prefix)
 	}
@@ -53,10 +50,10 @@ func parseLibp2pUrl(urlStr string) (*transportUrl, error) {
 		return nil, fmt.Errorf("expected only one address in url '%s'", urlStr)
 	}
 
-	return &transportUrl{
-		scheme:    libp2pScheme,
-		url:       libp2pScheme + "://" + addrInfo.ID.String(),
-		peerID:    addrInfo.ID,
-		multiaddr: addrInfo.Addrs[0],
+	return &TransportUrl{
+		Scheme:    Libp2pScheme,
+		Url:       Libp2pScheme + "://" + addrInfo.ID.String(),
+		PeerID:    addrInfo.ID,
+		Multiaddr: addrInfo.Addrs[0],
 	}, nil
 }
diff --git a/transport/httptransport/util_test.go b/transport/httptransport/util/util_test.go
similarity index 53%
rename from transport/httptransport/util_test.go
rename to transport/httptransport/util/util_test.go
index 71a1477b5..ddfd11193 100644
--- a/transport/httptransport/util_test.go
+++ b/transport/httptransport/util/util_test.go
@@ -1,4 +1,4 @@
-package httptransport
+package util
 
 import (
 	"testing"
@@ -12,21 +12,21 @@ func TestParseUrl(t *testing.T) {
 	tests := []struct {
 		name        string
 		url         string
-		expect      *transportUrl
+		expect      *TransportUrl
 		expectError bool
 	}{{
 		name: "http url",
 		url:  "http://www.test.com/path",
-		expect: &transportUrl{
-			url:    "http://www.test.com/path",
-			scheme: "http",
+		expect: &TransportUrl{
+			Url:    "http://www.test.com/path",
+			Scheme: "http",
 		},
 	}, {
 		name: "https url",
 		url:  "https://www.test.com/path",
-		expect: &transportUrl{
-			url:    "https://www.test.com/path",
-			scheme: "https",
+		expect: &TransportUrl{
+			Url:    "https://www.test.com/path",
+			Scheme: "https",
 		},
 	}, {
 		name:        "bad url",
@@ -35,37 +35,47 @@ func TestParseUrl(t *testing.T) {
 	}, {
 		name: "ip4 libp2p url",
 		url:  "libp2p:///ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
-		expect: &transportUrl{
-			scheme:    libp2pScheme,
-			url:       libp2pScheme + "://QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
-			peerID:    peerMustDecode(t, "QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ"),
-			multiaddr: multiAddrMustParse(t, "/ip4/104.131.131.82/tcp/4001"),
+		expect: &TransportUrl{
+			Scheme:    Libp2pScheme,
+			Url:       Libp2pScheme + "://QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
+			PeerID:    peerMustDecode(t, "QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ"),
+			Multiaddr: multiAddrMustParse(t, "/ip4/104.131.131.82/tcp/4001"),
 		},
 	}, {
 		name: "dns libp2p url",
 		url:  "libp2p:///dnsaddr/bootstrap.libp2p.io/ipfs/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
-		expect: &transportUrl{
-			scheme:    libp2pScheme,
-			url:       libp2pScheme + "://QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
-			peerID:    peerMustDecode(t, "QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb"),
-			multiaddr: multiAddrMustParse(t, "/dnsaddr/bootstrap.libp2p.io"),
+		expect: &TransportUrl{
+			Scheme:    Libp2pScheme,
+			Url:       Libp2pScheme + "://QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
+			PeerID:    peerMustDecode(t, "QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb"),
+			Multiaddr: multiAddrMustParse(t, "/dnsaddr/bootstrap.libp2p.io"),
+		},
+	}, {
+		name: "quic libp2p url",
+		url:  "libp2p:///ip4/1.2.3.4/udp/5678/quic/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
+		expect: &TransportUrl{
+			Scheme:    Libp2pScheme,
+			Url:       Libp2pScheme + "://QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
+			PeerID:    peerMustDecode(t, "QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb"),
+			Multiaddr: multiAddrMustParse(t, "/ip4/1.2.3.4/udp/5678/quic"),
 		},
 	}, {
 		name:        "libp2p url no peer ID",
 		url:         "libp2p:///ip4/104.131.131.82/tcp/4001",
 		expectError: true,
 	}}
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := parseUrl(tt.url)
+			got, err := ParseUrl(tt.url)
 			if tt.expectError {
 				require.Error(t, err)
 				return
 			} else {
 				require.NoError(t, err)
 			}
-			if tt.expect.multiaddr != nil {
-				require.Equal(t, tt.expect.multiaddr.String(), got.multiaddr.String())
+			if tt.expect.Multiaddr != nil {
+				require.Equal(t, tt.expect.Multiaddr.String(), got.Multiaddr.String())
 			}
 			require.Equal(t, tt.expect, got)
 		})