diff --git a/llarp/net/ip.cpp b/llarp/net/ip.cpp
index 8b8cc6cb8..32cb169c5 100644
--- a/llarp/net/ip.cpp
+++ b/llarp/net/ip.cpp
@@ -20,12 +20,12 @@ namespace llarp
     {
 #if __BYTE_ORDER == __BIG_ENDIAN
       return huint128_t{addr.s6_addr32[0]}
-      | (huint128_t{addr.s6_addr32[1]} << 32)
+          | (huint128_t{addr.s6_addr32[1]} << 32)
           | (huint128_t{addr.s6_addr32[2]} << 64)
           | (huint128_t{addr.s6_addr32[3]} << 96);
 #else
       return huint128_t{ntohl(addr.s6_addr32[3])}
-      | (huint128_t{ntohl(addr.s6_addr32[2])} << 32)
+          | (huint128_t{ntohl(addr.s6_addr32[2])} << 32)
           | (huint128_t{ntohl(addr.s6_addr32[1])} << 64)
           | (huint128_t{ntohl(addr.s6_addr32[0])} << 96);
 #endif
@@ -102,26 +102,6 @@ namespace llarp
       return huint32_t{ntohl(Header()->daddr)};
     }
 
-    void
-    IPPacket::UpdateV6Address(huint128_t src, huint128_t dst)
-    {
-      if(sz <= 40)
-        return;
-      auto hdr     = HeaderV6();
-      auto oldSrc = hdr->srcaddr;
-      auto oldDst = hdr->dstaddr;
-      hdr->srcaddr = HUIntToIn6(src);
-      hdr->dstaddr = HUIntToIn6(dst);
-      const size_t ihs = 40;
-      auto pld = buf + ihs;
-      auto psz = sz - ihs;
-      switch(hdr->proto)
-      {
-        //tcp
-        case 6:
-          return;
-      }
-    }
 
 #if 0
     static uint32_t
@@ -161,84 +141,16 @@ namespace llarp
     }
 #endif
 
-    static nuint16_t
-    deltaIPv4Checksum(nuint16_t old_sum, nuint32_t old_src_ip,
-                      nuint32_t old_dst_ip, nuint32_t new_src_ip,
-                      nuint32_t new_dst_ip)
-    {
-#define ADDIPCS(x) ((uint32_t)(x.n & 0xFFff) + (uint32_t)(x.n >> 16))
-#define SUBIPCS(x) ((uint32_t)((~x.n) & 0xFFff) + (uint32_t)((~x.n) >> 16))
-
-      uint32_t sum = uint32_t(old_sum.n) + ADDIPCS(old_src_ip)
-          + ADDIPCS(old_dst_ip) + SUBIPCS(new_src_ip) + SUBIPCS(new_dst_ip);
-
-#undef ADDIPCS
-#undef SUBIPCS
-
-      // only need to do it 2 times to be sure
-      // proof: 0xFFff + 0xFFff = 0x1FFfe -> 0xFFff
-      sum = (sum & 0xFFff) + (sum >> 16);
-      sum += sum >> 16;
-
-      return nuint16_t{uint16_t(sum & 0xFFff)};
-    }
-
-    static void
-    checksumDstIPv4TCP(byte_t *pld, ABSL_ATTRIBUTE_UNUSED size_t psz,
-                       size_t fragoff, size_t chksumoff, nuint32_t oSrcIP,
-                       nuint32_t oDstIP, nuint32_t nSrcIP, nuint32_t nDstIP)
-    {
-      if(fragoff > chksumoff)
-        return;
-
-      auto check = (nuint16_t *)(pld + chksumoff - fragoff);
-
-      *check = deltaIPv4Checksum(*check, oSrcIP, oDstIP, nSrcIP, nDstIP);
-      // usually, TCP checksum field cannot be 0xFFff,
-      // because one's complement addition cannot result in 0x0000,
-      // and there's inversion in the end;
-      // emulate that.
-      if(check->n == 0xFFff)
-        check->n = 0x0000;
-    }
-
-    static void
-    checksumDstIPv4UDP(byte_t *pld, ABSL_ATTRIBUTE_UNUSED size_t psz,
-                       size_t fragoff, nuint32_t oSrcIP, nuint32_t oDstIP,
-                       nuint32_t nSrcIP, nuint32_t nDstIP)
-    {
-      if(fragoff > 6)
-        return;
-
-      auto check = (nuint16_t *)(pld + 6);
-      if(check->n == 0x0000)
-        return;  // 0 is used to indicate "no checksum", don't change
-
-      *check = deltaIPv4Checksum(*check, oSrcIP, oDstIP, nSrcIP, nDstIP);
-      // 0 is used to indicate "no checksum"
-      // 0xFFff and 0 are equivalent in one's complement math
-      // 0xFFff + 1 = 0x10000 -> 0x0001 (same as 0 + 1)
-      // infact it's impossible to get 0 with such addition,
-      // when starting from non-0 value.
-      // inside deltachksum we don't invert so it's safe to skip check there
-      // if(check->n == 0x0000)
-      //   check->n = 0xFFff;
-    }
 
     void
-    IPPacket::UpdateV4Address(huint32_t newSrcIP, huint32_t newDstIP)
+    IPPacket::UpdateIPv4Address(nuint32_t nSrcIP, nuint32_t nDstIP)
     {
       llarp::LogDebug("set src=", newSrcIP, " dst=", newDstIP);
+
       auto hdr = Header();
 
       auto oSrcIP = nuint32_t{hdr->saddr};
       auto oDstIP = nuint32_t{hdr->daddr};
-      auto nSrcIP = xhtonl(newSrcIP);
-      auto nDstIP = xhtonl(newDstIP);
-
-      // IPv4 checksum
-      auto v4chk = (nuint16_t *)&(hdr->check);
-      *v4chk     = deltaIPv4Checksum(*v4chk, oSrcIP, oDstIP, nSrcIP, nDstIP);
 
       // L4 checksum
       auto ihs = size_t(hdr->ihl * 4);
@@ -267,23 +179,98 @@ namespace llarp
         }
       }
 
+      // IPv4 checksum
+      auto v4chk = (nuint16_t *)&(hdr->check);
+      *v4chk     = deltaIPv4Checksum(*v4chk, oSrcIP, oDstIP, nSrcIP, nDstIP);
+
       // write new IP addresses
       hdr->saddr = nSrcIP.n;
       hdr->daddr = nDstIP.n;
     }
 
+
+#define ADD32CS(x) ((uint32_t)(x & 0xFFff) + (uint32_t)(x >> 16))
+#define SUB32CS(x) ((uint32_t)((~x) & 0xFFff) + (uint32_t)((~x) >> 16))
+
+    static nuint16_t
+    deltaIPv4Checksum(nuint16_t old_sum, nuint32_t old_src_ip,
+                      nuint32_t old_dst_ip, nuint32_t new_src_ip,
+                      nuint32_t new_dst_ip)
+    {
+
+      uint32_t sum = uint32_t(old_sum.n) +
+        ADD32CS(old_src_ip.n) + ADD32CS(old_dst_ip.n) +
+        SUB32CS(new_src_ip.n) + SUB32CS(new_dst_ip.n);
+
+      // only need to do it 2 times to be sure
+      // proof: 0xFFff + 0xFFff = 0x1FFfe -> 0xFFff
+      sum = (sum & 0xFFff) + (sum >> 16);
+      sum += sum >> 16;
+
+      return nuint16_t{uint16_t(sum & 0xFFff)};
+    }
+
+    static nuint16_t
+    deltaIPv6Checksum(nuint16_t old_sum,
+                      const uint32 old_src_ip[4], const uint32 old_dst_ip[4],
+                      const uint32 new_src_ip[4], const uint32 new_dst_ip[4])
+    {
+      /* we don't actually care in what way integers are arranged in memory internally */
+      /* as long as uint16 pairs are swapped in correct direction, result will be correct (assuming there are no gaps in structure) */
+      /* we represent 128bit stuff there as 4 32bit ints, that should be more or less correct */
+      /* we could do 64bit ints too but then we couldn't reuse 32bit macros and that'd suck for 32bit cpus */
+#define ADDN128CS(x) (ADD32CS(x[0]) + ADD32CS(x[1]) + ADD32CS(x[2]) + ADD32CS(x[3]))
+#define SUBN128CS(x) (SUB32CS(x[0]) + SUB32CS(x[1]) + SUB32CS(x[2]) + SUB32CS(x[3]))
+      uint32_t sum = uint32_t(old_sum) +
+        ADDN128CS(old_src_ip) + ADDN128CS(old_dst_ip) +
+        SUBN128CS(new_src_ip) + SUBN128CS(new_dst_ip);
+#undef ADDN128CS
+#undef SUBN128CS
+
+      // only need to do it 2 times to be sure
+      // proof: 0xFFff + 0xFFff = 0x1FFfe -> 0xFFff
+      sum = (sum & 0xFFff) + (sum >> 16);
+      sum += sum >> 16;
+
+      return nuint16_t{uint16_t(sum & 0xFFff)};
+    }
+
+#undef ADD32CS
+#undef SUB32CS
+
+    void
+    IPPacket::UpdateIPv6Address(huint128_t src, huint128_t dst)
+    {
+      if(sz <= 40)
+        return;
+      auto hdr     = HeaderV6();
+      auto oldSrc = hdr->srcaddr;
+      auto oldDst = hdr->dstaddr;
+      hdr->srcaddr = HUIntToIn6(src);
+      hdr->dstaddr = HUIntToIn6(dst);
+      const size_t ihs = 40;
+      auto pld = buf + ihs;
+      auto psz = sz - ihs;
+      switch(hdr->proto)
+      {
+        //tcp
+        case 6:
+          return;
+      }
+    }
+
+
     static void
-    checksumSrcIPv4TCP(byte_t *pld, ABSL_ATTRIBUTE_UNUSED size_t psz,
+    deltaChecksumIPv4TCP(byte_t *pld, ABSL_ATTRIBUTE_UNUSED size_t psz,
                        size_t fragoff, size_t chksumoff, nuint32_t oSrcIP,
-                       nuint32_t oDstIP)
+                       nuint32_t oDstIP, nuint32_t nSrcIP, nuint32_t nDstIP)
     {
       if(fragoff > chksumoff)
         return;
 
       auto check = (nuint16_t *)(pld + chksumoff - fragoff);
 
-      *check =
-          deltaIPv4Checksum(*check, oSrcIP, oDstIP, nuint32_t{0}, nuint32_t{0});
+      *check = deltaIPv4Checksum(*check, oSrcIP, oDstIP, nSrcIP, nDstIP);
       // usually, TCP checksum field cannot be 0xFFff,
       // because one's complement addition cannot result in 0x0000,
       // and there's inversion in the end;
@@ -293,8 +280,9 @@ namespace llarp
     }
 
     static void
-    checksumSrcIPv4UDP(byte_t *pld, ABSL_ATTRIBUTE_UNUSED size_t psz,
-                       size_t fragoff, nuint32_t oSrcIP, nuint32_t oDstIP)
+    deltaChecksumIPv4UDP(byte_t *pld, ABSL_ATTRIBUTE_UNUSED size_t psz,
+                       size_t fragoff, nuint32_t oSrcIP, nuint32_t oDstIP,
+                       nuint32_t nSrcIP, nuint32_t nDstIP)
     {
       if(fragoff > 6)
         return;
@@ -303,8 +291,7 @@ namespace llarp
       if(check->n == 0x0000)
         return;  // 0 is used to indicate "no checksum", don't change
 
-      *check =
-          deltaIPv4Checksum(*check, oSrcIP, oDstIP, nuint32_t{0}, nuint32_t{0});
+      *check = deltaIPv4Checksum(*check, oSrcIP, oDstIP, nSrcIP, nDstIP);
       // 0 is used to indicate "no checksum"
       // 0xFFff and 0 are equivalent in one's complement math
       // 0xFFff + 1 = 0x10000 -> 0x0001 (same as 0 + 1)
@@ -314,48 +301,5 @@ namespace llarp
       // if(check->n == 0x0000)
       //   check->n = 0xFFff;
     }
-    /*
-    void
-    IPacket::UpdateIPv4PacketOnSrc()
-    {
-      auto hdr = Header();
-
-      auto oSrcIP = nuint32_t{hdr->saddr};
-      auto oDstIP = nuint32_t{hdr->daddr};
-
-      // L4
-      auto ihs = size_t(hdr->ihl * 4);
-      if(ihs <= sz)
-      {
-        auto pld = buf + ihs;
-        auto psz = sz - ihs;
-
-        auto fragoff = size_t((ntohs(hdr->frag_off) & 0x1Fff) * 8);
-
-        switch(hdr->protocol)
-        {
-          case 6:  // TCP
-            checksumSrcIPv4TCP(pld, psz, fragoff, 16, oSrcIP, oDstIP);
-            break;
-          case 17:   // UDP
-          case 136:  // UDP-Lite
-            checksumSrcIPv4UDP(pld, psz, fragoff, oSrcIP, oDstIP);
-            break;
-          case 33:  // DCCP
-            checksumSrcIPv4TCP(pld, psz, fragoff, 6, oSrcIP, oDstIP);
-            break;
-        }
-      }
-
-      // IPv4
-      auto v4chk = (nuint16_t *)&(hdr->check);
-      *v4chk =
-          deltaIPv4Checksum(*v4chk, oSrcIP, oDstIP, nuint32_t{0}, nuint32_t{0});
-
-      // clear addresses
-      hdr->saddr = 0;
-      hdr->daddr = 0;
-    }
-    */
   }  // namespace net
 }  // namespace llarp