How to setup V1 Relay in the new config

As the new config changed to Circuit Relay V2.

But in a note(Releases · ipfs/go-ipfs · GitHub) that they clearly mentioned saying for bitswap sessions we need to still port back to V1 in the config.

How do I setup that and still use my values like EnableRelayHop/AutoRelayHop with the new config file in .ipfs.

go-ipfs doesn’t ship with circuit v1 builtin anymore.
You need a custom build.

Can you let me know or is there a readme on how I can custom built v1 for my config, so that I can use the bitswap sessions, as v2 mentions that they are a low bandwidth and can only be used for ping etc.

I could but before, why do you think bitswap sessions is linked to relay ?

Bitswap sessions is totaly unrelated to relay and is just part of the API that the go-bitswap lib provides.
Sessions are used to hint your client about related blocks and aren’t even transmited over the wire.

(what are you trying to do ?)

I think you are missing the point. The new relay v2 doesn’t support bitswap because it doesn’t need to, it’s just there as a meeting point for “hole punching”, and then bitswap will use the “hole punched” direct connection between the two nodes, which is vastly more efficient than the v1 relayed way. It isn’t enabled by default … yet:

ipfs config --json Swarm.EnableHolePunching true

On a private network we used to connect to two systems which are sitting on different networks through relay.
The relay machine had EnableRelay: true, by which we were able to connect

ipfs swarm connect /relay-node-address/p2p-circuit/p2p/destination-node

This helped us to read/pull data from each other through relay. To send/receive blocks/data bitswap is responsible right?

So, now in the new documentation/readme where they mentioned

“Note: the limited Circuit Relay v2 provided with this release only allows low-bandwidth protocols (identify, ping, holepunch) over transient connections. If you want to relay things like bitswap sessions, you need to set up a v1 relay by some other means. See details below”

I thought V2 doesn’t support heavy data transfer or so. So, was looking for ways to fall back.

Let me know if I got it wrong :slight_smile:
If I am missing anything too, please do let me know.

Thank you

One node can have RelayService : Enabled : true
Other nodes will connect to it using RelayClient : Enabled : true
and the HolePunching : true.
This should help me to get and receive data from my other nodes rights?

Thank you

The hole punching mechanism is there to connect 2 nodes that are each behind their own NAT router and cannot use port forwarding. This assumes that each side can reach the other side’s router and that NAT is the only issue.

When you say “different networks”, what do you mean exactly? What is the actual layout? Also, this is the first time you mention this is a private network, which has its own pitfalls.

Before moving to V2.
My connection used to work the following way.
A,B (source & destination), C (public address node)
// A and B are sitting countries apart :slight_smile:
C has EnableRelayHop : true while using the old config
A and B can connect to C and then A connects to B using /ip4/C-ip-address/tcp/4001/p2p/C node ID/p2p-circuit/p2p/B node ID

So this makes A connected to B via C and can exchange data if the other node has the hash.

All the above in a private network.

But now the A to B via C is not being possible with V2 config or I am missing something even after enabling the RelayClient : true on A and B and RelayService : true on C and swarm connect from A to B via C is giving the below error.

error opening relay circuit: HOP_CANT_SPEAK_RELAY (270)

You’re still not telling me what I really need to know. What is the reason A & B cannot open a connection to each other (TCP or UDP, unrelated to IPFS)? What is blocking them? Is it NAT or something else?

Yes they are behind NAT.
I mean to transfer data if they both are behind NAT, then we need to connect through relay machine and that will help us transfer data right. This was my understanding till now and did the same way setup as I explained above.

Let me know if I am doing any wrong or getting it wrong

This code has been removed because it wasn’t effective, you would need to add it back in a custom build if you want to use it.

Now we are talking.

There is a way to establish a direct connection between the two, and that’s what hole punching is. It needs the relay’s help to do that, but once established, it’s a direct connection that no longer involves the relay, and is vastly more efficient.

You’ll need to set up a few things:

  • you said you have a private network. that means A & B must have C as a bootstrap
  • enable RelayService on C
  • enable RelayClient on A & B
  • enable hole punching on A & B
  • (optional) set up peering between A & B, so that they stay connected any time they are both up (you only need the peer IDs, they’ll figure out the address themselves)

If you do all that, both A & B will connect to C and advertise their address through C as a relay. Then peering will cause them to try and connect to each other. They will use C as a relay to establish a hole-punched connection to each other (direct connection), and then the peering will cause them to stay connected forever, or automatically reconnect when a node comes back after being shut down.

I used that setup for a while and it works great (not a private network though). Since then, I’ve established proper port forwarding, so I no longer do that.

For more information on hole punching, read the following:

On my machine A & B
I just do the following:

  1. ipfs init
  2. ipfs config --json Swarm.EnableHolePunching true
  3. ipfs config --json Swarm.RelayClient.Enabled true

On my machine C
I just do the following

  1. ipfs init
  2. ipfs config --json Swarm.RelayService.Enabled true

Then from my A & B, I run the daemon and I run ipfs swarm connect node-C-address and they will connect to C.

Is the above configuration sufficient to setup as you mentioned above?

Can you clarify/elaborate on

(optional) set up peering between A & B, so that they stay connected any time they are both up

How do we do this too?

In A & B config Swarm.RelayClient which takes a object. Do we need to give the node-C-address?
If I can have a sample/example config it would be great.

Thank you for your help :slight_smile:

It depends on what you mean by “private network”. I took it to mean that your nodes were not connected to the main IPFS network, and that you were using a private network key, so that your entire network is just your 3 nodes. Is that correct, or are you using the normal IPFS network (things will be different depending on your answer).

Correct.
I use swarm.key inside my .ipfs folder which keeps my network private and all the three nodes A B C will have the same swarm.key.

Since you are running a private network, A & B should have C in their bootstrap list (and nothing else). Bring up C, then bring up A & B. A & B should automatically connect to C to discover the network (and probably will connect to each other because there’s not much else to connect to). Once that is done, run the command ipfs id <peer_id_of_B> on A to see what addresses B is advertising (they should be relay addresses through C), and then do the same from B to see what A is advertising. Also, run ipfs swarm peers on both A & B to see what they are connected to (you should at least see a connection to C, and probably a connection to the other one if things are configured right).

If you want to peer A & B, put the following in A&B’s config files (in the right spot):

"Peering": {
	"Peers": [
		{
			"Addrs": [],
			"ID": "<peer_id_of_other_node>"
		}
	]
},

This will cause them both to reach out for each other and stay connected.

If you run into problems, please post the output of the various commands I gave you to this thread, and we’ll go from there.

Node A/B config

{
“API”: {
“HTTPHeaders”: {}
},
“Addresses”: {
“API”: “/ip4/127.0.0.1/tcp/5001”,
“Announce”: ,
“AppendAnnounce”: ,
“Gateway”: “/ip4/127.0.0.1/tcp/8080”,
“NoAnnounce”: ,
“Swarm”: [
“/ip4/0.0.0.0/tcp/4001”,
“/ip6/::/tcp/4001”,
“/ip4/0.0.0.0/udp/4001/quic”,
“/ip6/::/udp/4001/quic”
]
},
“AutoNAT”: {},
“Bootstrap”: [
“/ip4/node-c-ip/tcp/4001/p2p/node-c-peer-id”
],
“DNS”: {
“Resolvers”: {}
},
“Datastore”: {
“BloomFilterSize”: 0,
“GCPeriod”: “1h”,
“HashOnRead”: false,
“Spec”: {
“child”: {
“path”: “badgerds”,
“syncWrites”: false,
“truncate”: true,
“type”: “badgerds”
},
“prefix”: “badger.datastore”,
“type”: “measure”
},
“StorageGCWatermark”: 90,
“StorageMax”: “10GB”
},
“Discovery”: {
“MDNS”: {
“Enabled”: true,
“Interval”: 10
}
},
“Experimental”: {
“AcceleratedDHTClient”: false,
“FilestoreEnabled”: false,
“GraphsyncEnabled”: false,
“Libp2pStreamMounting”: false,
“P2pHttpProxy”: false,
“StrategicProviding”: false,
“UrlstoreEnabled”: false
},
“Gateway”: {
“APICommands”: ,
“HTTPHeaders”: {
“Access-Control-Allow-Headers”: [
“X-Requested-With”,
“Range”,
“User-Agent”
],
“Access-Control-Allow-Methods”: [
“GET”
],
“Access-Control-Allow-Origin”: [
“*”
]
},
“NoDNSLink”: false,
“NoFetch”: false,
“PathPrefixes”: ,
“PublicGateways”: null,
“RootRedirect”: “”,
“Writable”: false
},
“Identity”: {
“PeerID”: “12D*****************”,
“PrivKey”: “CAESQLQBB0DoIw4vJoYdLZyFgsvv4yXd+kpLx3oLGWYYhiZE/1gs0Pf+A3IFlrao**************************”
},
“Internal”: {},
“Ipns”: {
“RecordLifetime”: “”,
“RepublishPeriod”: “”,
“ResolveCacheSize”: 128
},
“Migration”: {
“DownloadSources”: ,
“Keep”: “”
},
“Mounts”: {
“FuseAllowOther”: false,
“IPFS”: “/ipfs”,
“IPNS”: “/ipns”
},
“Peering”: {
“Peers”: [
{
“Addrs”: [
“/ip4/node-c-ip/tcp/4001”,
],
“ID”: “node-c-peer-id”
}
]
},
“Pinning”: {
“RemoteServices”: {}
},
“Plugins”: {
“Plugins”: null
},
“Provider”: {
“Strategy”: “”
},
“Pubsub”: {
“DisableSigning”: false,
“Router”: “”
},
“Reprovider”: {
“Interval”: “12h”,
“Strategy”: “all”
},
“Routing”: {
“Type”: “dht”
},
“Swarm”: {
“AddrFilters”: null,
“ConnMgr”: {
“GracePeriod”: “20s”,
“HighWater”: 900,
“LowWater”: 600,
“Type”: “basic”
},
“DisableBandwidthMetrics”: false,
“DisableNatPortMap”: false,
“EnableHolePunching”: true,
“RelayClient”: {
“Enabled”: true
},
“RelayService”: {},
“Transports”: {
“Multiplexers”: {},
“Network”: {},
“Security”: {}
}
}
}

Node C config

{
“API”: {
“HTTPHeaders”: {}
},
“Addresses”: {
“API”: “/ip4/0.0.0.0/tcp/5001”,
“Announce”: ,
“AppendAnnounce”: ,
“Gateway”: “/ip4/0.0.0.0/tcp/8080”,
“NoAnnounce”: ,
“Swarm”: [
“/ip4/0.0.0.0/tcp/4001”,
“/ip6/::/tcp/4001”,
“/ip4/0.0.0.0/udp/4001/quic”,
“/ip6/::/udp/4001/quic”
]
},
“AutoNAT”: {},
“Bootstrap”: null,
“DNS”: {
“Resolvers”: {}
},
“Datastore”: {
“BloomFilterSize”: 0,
“GCPeriod”: “1h”,
“HashOnRead”: false,
“Spec”: {
“child”: {
“path”: “badgerds”,
“syncWrites”: false,
“truncate”: true,
“type”: “badgerds”
},
“prefix”: “badger.datastore”,
“type”: “measure”
},
“StorageGCWatermark”: 90,
“StorageMax”: “20GB”
},
“Discovery”: {
“MDNS”: {
“Enabled”: true,
“Interval”: 10
}
},
“Experimental”: {
“AcceleratedDHTClient”: false,
“FilestoreEnabled”: false,
“GraphsyncEnabled”: false,
“Libp2pStreamMounting”: false,
“P2pHttpProxy”: false,
“StrategicProviding”: false,
“UrlstoreEnabled”: false
},
“Gateway”: {
“APICommands”: ,
“HTTPHeaders”: {
“Access-Control-Allow-Headers”: [
“X-Requested-With”,
“Range”,
“User-Agent”
],
“Access-Control-Allow-Methods”: [
“GET”
],
“Access-Control-Allow-Origin”: [
"
]
},
“NoDNSLink”: false,
“NoFetch”: false,
“PathPrefixes”: [],
“PublicGateways”: null,
“RootRedirect”: “”,
“Writable”: false
},
“Identity”: {
“PeerID”: "12D
***********************************”
},
“Internal”: {},
“Ipns”: {
“RecordLifetime”: “”,
“RepublishPeriod”: “”,
“ResolveCacheSize”: 128
},
“Migration”: {
“DownloadSources”: ,
“Keep”: “”
},
“Mounts”: {
“FuseAllowOther”: false,
“IPFS”: “/ipfs”,
“IPNS”: “/ipns”
},
“Peering”: {
“Peers”: null
},
“Pinning”: {
“RemoteServices”: {}
},
“Plugins”: {
“Plugins”: null
},
“Provider”: {
“Strategy”: “”
},
“Pubsub”: {
“DisableSigning”: false,
“Router”: “”
},
“Reprovider”: {
“Interval”: “12h”,
“Strategy”: “all”
},
“Routing”: {
“Type”: “dht”
},
“Swarm”: {
“AddrFilters”: null,
“ConnMgr”: {
“GracePeriod”: “20s”,
“HighWater”: 900,
“LowWater”: 600,
“Type”: “basic”
},
“DisableBandwidthMetrics”: false,
“DisableNatPortMap”: false,
“RelayClient”: {},
“RelayService”: {
“Enabled”: true
},
“Transports”: {
“Multiplexers”: {},
“Network”: {},
“Security”: {}
}
}
}

When I ran my daemon, A got connected to C and B got connected to C.
Then from my A machine I ran ipfs id node-B-peer-id and below is the following error I got:

Error: failed to dial node-B-peer-id:

  • [/p2p/node-C-peer-id/p2p-circuit] error opening relay circuit: HOP_CANT_SPEAK_RELAY (270)
  • [/ip4/ip address/tcp/52438] dial tcp4 0.0.0.0:4001->ip address:52438: i/o timeout
  • [/ip4/ip address/tcp/45182] dial tcp4 0.0.0.0:4001->ip address:45182: i/o timeout
  • [/ip4/ip address/tcp/4001] dial tcp4 0.0.0.0:4001->ip address:4001: i/o timeout

So, stuck here.
Thank you

OK, try a couple things:

First, type ipfs id on C and post that here, then type it on A or B and post it here.

Next, remove the RelayService.Enabled from C and bring it up, then type ipfs id on C and post it here.

Then, type ipfs id <B_peer_id> on A and post that here.

Hopefully, there will be a hint of what is going on in those messages (or, removing the enabled from C will actually make things work, as it’s supposed to be on by default for the purpose of hole punching).

I’ll include the material from the release notes here, so you can see what I’m working with (again, I had this setup working for me before, but I only had 2 clients, I was relying on a relay server somewhere on the ipfs network, so I don’t really know how that one is set up):


:repeat: Circuit Relay v2

This release adds support for the circuit relay v2 protocol based on the reference implementation from go-libp2p 0.16.

This is the cornerstone for maximizing p2p connections between IPFS peers. Every publicly dialable peer can now act as a limited relay v2, which can be used for hole punching and other decentralized signaling protocols.

Limited relay v2 configuration options

go-ipfs can now be configured to act as a RelayClient that uses other peers for autorelay functionality when behind a NAT, or provide a limited RelayService to other peers on the network.

Starting with go-ipfs v0.11 every publicly dialable go-ipfs (based on AutoNAT determination) will start a limited RelayService . RelayClient remains disabled by default for now, as we want the network to update and get enough v2 service providers first.

Note: the limited Circuit Relay v2 provided with this release only allows low-bandwidth protocols (identify, ping, holepunch) over transient connections. If you want to relay things like bitswap sessions, you need to set up a v1 relay by some other means. See details below.

Removal of unlimited v1 relay service provider

Switching to v2 of the relay spec means removal or deprecation of configuration keys that were specific to v1.

  • Relay transport and client support circuit-relay v2:
    • Swarm.EnableAutoRelay was replaced by Swarm.RelayClient.Enable .
    • Swarm.DisableRelay is deprecated, relay transport can be now disabled globally (both client and service) by setting Swarm.Transports.Network.Relay to false
  • Relay v1 service provider was replaced by v2:
    • Swarm.EnableRelayHop no longer starts an unlimited v1 relay. If you have it set to true the node will refuse to start and display an error message.
    • Existing users who choose to continue running a v1 relay should migrate their setups to relay v1 based on js-ipfs running in node, or the standalone libp2p-relay-daemon configured with RelayV1.Enabled set to true . Be mindful that v1 relays are unlimited, and one may want to set up some ACL based either on PeerIDs or Subnets.

:hole: Decentralized Hole Punching (DCUtR protocol client)

We are working towards enabling hole punching for NAT traversal when port forwarding is not possible.

go-libp2p 0.16 provides an implementation of the DCUtR (decentralized hole punching) protocol. It is hidden behind the Swarm.EnableHolePunching configuration flag.

When enabled, go-ipfs will coordinate with the counterparty using a relayed v2 connection, to upgrade to a direct connection through a NAT/firewall whenever possible.

This feature is disabled by default in this release, but we hope to enable it by default as soon the network updates to go-ipfs v0.11 and gains a healthy set of limited v2 relays.

ipfs id on C

{
“ID”: “12D3KooWT187aTvpbyurLUgZjLZtFS18xcDz1um2GMvFDekDycMn”,
“PublicKey”: “CAESIE6h+Ymv4ba/Kujbggf9jWw**************”,
“Addresses”: [
“/ip4/10.1.193.173/tcp/4001/p2p/12D3KooWF7KDk87dvSDTdPR3nYqc5rWmFpLqc85wzz4jL1pFMT2V”,
“/ip4/127.0.0.1/tcp/4001/p2p/12D3KooWF7KDk87dvSDTdPR3nYqc5rWmFpLqc85wzz4jL1pFMT2V”
],
“AgentVersion”: “go-ipfs/0.13.0-dev/daa9beb7”,
“ProtocolVersion”: “ipfs/0.1.0”,
“Protocols”: [
“/floodsub/1.0.0”,
“/ipfs/bitswap”,
“/ipfs/bitswap/1.0.0”,
“/ipfs/bitswap/1.1.0”,
“/ipfs/bitswap/1.2.0”,
“/ipfs/id/1.0.0”,
“/ipfs/id/push/1.0.0”,
“/ipfs/lan/kad/1.0.0”,
“/ipfs/ping/1.0.0”,
“/libp2p/autonat/1.0.0”,
“/libp2p/circuit/relay/0.1.0”,
“/libp2p/circuit/relay/0.2.0/stop”,
“/meshsub/1.0.0”,
“/meshsub/1.1.0”,
“/p2p/id/delta/1.0.0”,
“/x/”
]
}

ipfs id on A

{
“ID”: “12D3KooWT187aTvpbyurLUgZjLZtFS18xcDz1um2GMvFDekDycMn”,
“PublicKey”: “CAESIP9YLND3/gNyBZa2qD/DVAq2XyZXiq***************”,
“Addresses”: [
“/ip4/10.191.244.206/tcp/55259/p2p/12D3KooWT187aTvpbyurLUgZjLZtFS18xcDz1um2GMvFDekDycMn”,
“/ip4/127.0.0.1/tcp/4001/p2p/12D3KooWT187aTvpbyurLUgZjLZtFS18xcDz1um2GMvFDekDycMn”,
“/ip4/192.168.1.127/tcp/4001/p2p/12D3KooWT187aTvpbyurLUgZjLZtFS18xcDz1um2GMvFDekDycMn”,
“/ip6/::1/tcp/4001/p2p/12D3KooWT187aTvpbyurLUgZjLZtFS18xcDz1um2GMvFDekDycMn”
],
“AgentVersion”: “go-ipfs/0.13.0-dev/daa9beb7”,
“ProtocolVersion”: “ipfs/0.1.0”,
“Protocols”: [
“/floodsub/1.0.0”,
“/ipfs/bitswap”,
“/ipfs/bitswap/1.0.0”,
“/ipfs/bitswap/1.1.0”,
“/ipfs/bitswap/1.2.0”,
“/ipfs/id/1.0.0”,
“/ipfs/id/push/1.0.0”,
“/ipfs/lan/kad/1.0.0”,
“/ipfs/ping/1.0.0”,
“/libp2p/autonat/1.0.0”,
“/libp2p/circuit/relay/0.1.0”,
“/libp2p/circuit/relay/0.2.0/stop”,
“/meshsub/1.0.0”,
“/meshsub/1.1.0”,
“/p2p/id/delta/1.0.0”,
“/x/”
]
}

ipfs id on B

{
“ID”: “12D3KooWHu2mxR4ZgQko4SUPdnRWCJiVTdnNafCPdyUzbRGL4R4h”,
“PublicKey”: “CAESIHgPeMofzc4TfexjlA07R3YU8ioJC+z6r*************”,
“Addresses”: [
“/ip4/10.133.11.255/tcp/60852/p2p/12D3KooWHu2mxR4ZgQko4SUPdnRWCJiVTdnNafCPdyUzbRGL4R4h”,
“/ip4/127.0.0.1/tcp/4001/p2p/12D3KooWHu2mxR4ZgQko4SUPdnRWCJiVTdnNafCPdyUzbRGL4R4h”,
“/ip4/192.168.0.127/tcp/4001/p2p/12D3KooWHu2mxR4ZgQko4SUPdnRWCJiVTdnNafCPdyUzbRGL4R4h”,
“/ip6/::1/tcp/4001/p2p/12D3KooWHu2mxR4ZgQko4SUPdnRWCJiVTdnNafCPdyUzbRGL4R4h”,
“/ip6/fd01::b849:8849:cb3f:b465/tcp/4001/p2p/12D3KooWHu2mxR4ZgQko4SUPdnRWCJiVTdnNafCPdyUzbRGL4R4h”
],
“AgentVersion”: “go-ipfs/0.13.0-dev/daa9beb7”,
“ProtocolVersion”: “ipfs/0.1.0”,
“Protocols”: [
“/floodsub/1.0.0”,
“/ipfs/bitswap”,
“/ipfs/bitswap/1.0.0”,
“/ipfs/bitswap/1.1.0”,
“/ipfs/bitswap/1.2.0”,
“/ipfs/id/1.0.0”,
“/ipfs/id/push/1.0.0”,
“/ipfs/lan/kad/1.0.0”,
“/ipfs/ping/1.0.0”,
“/libp2p/autonat/1.0.0”,
“/libp2p/circuit/relay/0.1.0”,
“/libp2p/circuit/relay/0.2.0/stop”,
“/meshsub/1.0.0”,
“/meshsub/1.1.0”,
“/p2p/id/delta/1.0.0”,
“/x/”
]
}

When typed ipfs id B on A machine

Error: failed to dial 12D3KooWHu2mxR4ZgQko4SUPdnRWCJiVTdnNafCPdyUzbRGL4R4h:

  • [/p2p/12D3KooWF7KDk87dvSDTdPR3nYqc5rWmFpLqc85wzz4jL1pFMT2V/p2p-circuit] error opening relay circuit: HOP_CANT_SPEAK_RELAY (270)
  • [/ip4/192.168.0.127/tcp/4001] dial tcp4 0.0.0.0:4001->192.168.0.127:4001: i/o timeout
  • [/ip4/10.133.11.255/tcp/60852] dial tcp4 0.0.0.0:4001->10.133.11.255:60852: i/o timeout
  • [/ip4/10.133.11.255/tcp/27222] dial tcp4 0.0.0.0:4001->10.133.11.255:27222: i/o timeout
  • [/ip4/10.133.11.255/tcp/51554] dial tcp4 0.0.0.0:4001->10.133.11.255:51554: i/o timeout
  • [/ip4/192.168.88.9/tcp/4001] dial tcp4 0.0.0.0:4001->192.168.88.9:4001: i/o timeout

Removing RelayService.Enabled from C

ipfs id on C

{
“ID”: “12D3KooWF7KDk87dvSDTdPR3nYqc5rWmFpLqc85wzz4jL1pFMT2V”,
“PublicKey”: “CAESIE6h+Ymv4ba/Kujbggf9jWw+LbzZoSx**************”,
“Addresses”: [
“/ip4/10.1.214.67/tcp/4001/p2p/12D3KooWF7KDk87dvSDTdPR3nYqc5rWmFpLqc85wzz4jL1pFMT2V”,
“/ip4/127.0.0.1/tcp/4001/p2p/12D3KooWF7KDk87dvSDTdPR3nYqc5rWmFpLqc85wzz4jL1pFMT2V”
],
“AgentVersion”: “go-ipfs/0.13.0-dev/daa9beb7”,
“ProtocolVersion”: “ipfs/0.1.0”,
“Protocols”: [
“/floodsub/1.0.0”,
“/ipfs/bitswap”,
“/ipfs/bitswap/1.0.0”,
“/ipfs/bitswap/1.1.0”,
“/ipfs/bitswap/1.2.0”,
“/ipfs/id/1.0.0”,
“/ipfs/id/push/1.0.0”,
“/ipfs/lan/kad/1.0.0”,
“/ipfs/ping/1.0.0”,
“/libp2p/autonat/1.0.0”,
“/libp2p/circuit/relay/0.1.0”,
“/libp2p/circuit/relay/0.2.0/stop”,
“/meshsub/1.0.0”,
“/meshsub/1.1.0”,
“/p2p/id/delta/1.0.0”,
“/x/”
]
}

When typed ipfs id B on A machine

Error: failed to dial 12D3KooWHu2mxR4ZgQko4SUPdnRWCJiVTdnNafCPdyUzbRGL4R4h:

  • [/ip4/10.133.11.255/tcp/51554] dial backoff
  • [/ip4/192.168.88.9/tcp/4001] dial backoff
  • [/ip4/10.133.11.255/tcp/60852] dial backoff
  • [/ip4/10.133.11.255/tcp/54555] dial backoff
  • [/ip4/10.133.11.255/tcp/27222] dial backoff
  • [/ip4/192.168.0.127/tcp/4001] dial backoff
  • [/p2p/12D3KooWF7KDk87dvSDTdPR3nYqc5rWmFpLqc85wzz4jL1pFMT2V/p2p-circuit] error opening relay circuit: HOP_CANT_SPEAK_RELAY (270)

Let me know if any more information is required
Thank you