cryptix/caberl - Change ND3IVKX4JO4NLMET5NNHEAGPZVE3A54CO5QFQWCAIEVKLEDOSAHAC

wire -> cabal_wire

Created by Henry on December 16, 2025

ND3IVKX4JO4NLMET5NNHEAGPZVE3A54CO5QFQWCAIEVKLEDOSAHAC

Dependencies

In channels

main

Change contents

Replacement in test/cable_basic_SUITE.erl at line 11 [6.22]

∅:D[4.647] → [5.2:84]

B:BD[7.88] → [5.2:84]

    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, Decoded} = wire:decode(Msg),

[4.647]

[8.5039]

    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, Decoded} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 22 [6.22]

∅:D[4.724] → [5.140:222]

B:BD[9.542] → [5.140:222]

    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, Decoded} = wire:decode(Msg),

[4.724]

[8.5122]

    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, Decoded} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 31 [6.22]

∅:D[4.813] → [5.282:364]

B:BD[9.1174] → [5.282:364]

    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, Decoded} = wire:decode(Msg),

[4.813]

[8.5181]

    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, Decoded} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 53 [6.22]

∅:D[4.897] → [5.365:447]

B:BD[10.768] → [5.365:447]

    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, Decoded} = wire:decode(Msg),

[4.897]

[8.5390]

    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, Decoded} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 71 [6.22]

∅:D[4.979] → [5.448:530]

∅:D[8.5615] → [5.448:530]

B:BD[10.1180] → [5.448:530]

    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, Decoded} = wire:decode(Msg),

[8.5615]

[8.5616]

    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, Decoded} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 86 [6.22]

∅:D[4.1055] → [5.531:613]

B:BD[7.562] → [5.531:613]

    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, Decoded} = wire:decode(Msg),

[4.1055]

[8.5747]

    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, Decoded} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 96 [6.22]

∅:D[4.1131] → [5.614:696]

B:BD[11.474] → [5.614:696]

    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, Decoded} = wire:decode(Msg),

[4.1131]

[8.5792]

    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, Decoded} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 106 [6.22]

∅:D[4.1215] → [5.697:779]

B:BD[11.704] → [5.697:779]

    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, Decoded} = wire:decode(Msg),

[4.1215]

[8.5835]

    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, Decoded} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 115 [6.22]

B:BD[5.859] → [5.859:1010]

    Bin = wire:encode_channel_state_request(TH, "Foo", true),
    {ok, [Msg]} = wire:split_messages(Bin),
    {ok, [Header, Body]} = wire:decode(Msg),

[5.859]

[5.1010]

    Bin = cabal_wire:encode_channel_state_request(TH, "Foo", true),
    {ok, [Msg]} = cabal_wire:split_messages(Bin),
    {ok, [Header, Body]} = cabal_wire:decode(Msg),

Replacement in test/cable_basic_SUITE.erl at line 128 [6.22]
B:BD[5.1392] → [5.1392:1437]
```
    ALen = wire:encode_varint(byte_size(A)),
```
[5.1392]
[5.1437]
```
    ALen = cabal_wire:encode_varint(byte_size(A)),
```
Replacement in test/cable_basic_SUITE.erl at line 130 [6.22]
B:BD[5.1475] → [5.1475:1520]
```
    BLen = wire:encode_varint(byte_size(B)),
```
[5.1475]
[5.1520]
```
    BLen = cabal_wire:encode_varint(byte_size(B)),
```
Replacement in test/cable_basic_SUITE.erl at line 132 [6.22]
B:BD[5.1557] → [5.1557:1602]
```
    CLen = wire:encode_varint(byte_size(C)),
```
[5.1557]
[5.1602]
```
    CLen = cabal_wire:encode_varint(byte_size(C)),
```

Replacement in test/cable_basic_SUITE.erl at line 134 [6.22]

B:BD[5.1683] → [5.1683:1735]

    {ok, [A, B, C]} = wire:split_messages(Payload).

[5.1683]

[11.3258]

    {ok, [A, B, C]} = cabal_wire:split_messages(Payload).

Replacement in src/posts.erl at line 12 [11.5381]

B:BD[12.886] → [12.886:936]

    NumLinks = wire:encode_varint(length(Links)),

[12.886]

[12.936]

    NumLinks = cabal_wire:encode_varint(length(Links)),

Replacement in src/posts.erl at line 14 [11.5381]

B:BD[12.976] → [12.976:1034]

    Timestamp = wire:encode_varint(os:system_time(1000)),

[12.976]

[12.1034]

    Timestamp = cabal_wire:encode_varint(os:system_time(1000)),

Replacement in src/posts.erl at line 23 [11.5381]

B:BD[12.1392] → [12.1392:1446]

    ChanLen = wire:encode_varint(byte_size(ChanBin)),

[12.1392]

[12.1446]

    ChanLen = cabal_wire:encode_varint(byte_size(ChanBin)),

Replacement in src/posts.erl at line 25 [11.5381]

B:BD[12.1496] → [12.1496:1550]

    TextLen = wire:encode_varint(byte_size(TextBin)),

[12.1496]

[12.1550]

    TextLen = cabal_wire:encode_varint(byte_size(TextBin)),

Replacement in src/posts.erl at line 28 [11.5381]

B:BD[13.2551] → [13.2551:2603]

    NumHashes = wire:encode_varint(length(Hashes)),

[13.2551]

[13.2603]

    NumHashes = cabal_wire:encode_varint(length(Hashes)),

Replacement in src/posts.erl at line 33 [11.5381]

B:BD[13.2799] → [13.2799:2853]

    NameLen = wire:encode_varint(byte_size(NameBin)),

[13.2799]

[13.2853]

    NameLen = cabal_wire:encode_varint(byte_size(NameBin)),

Replacement in src/posts.erl at line 37 [11.5381]

B:BD[12.1694] → [14.3628:3682]

    ChanLen = wire:encode_varint(byte_size(ChanBin)),

[12.1694]

[8.12187]

    ChanLen = cabal_wire:encode_varint(byte_size(ChanBin)),

Replacement in src/posts.erl at line 44 [11.5381]

B:BD[8.12352] → [8.12352:12420]

                TopicLen = wire:encode_varint(byte_size(TopicBin)),

[8.12352]

[8.12420]

                TopicLen = cabal_wire:encode_varint(byte_size(TopicBin)),

Replacement in src/posts.erl at line 55 [11.5381]

B:BD[12.1872] → [14.3683:3737]

    ChanLen = wire:encode_varint(byte_size(ChanBin)),

[12.1872]

[13.3490]

    ChanLen = cabal_wire:encode_varint(byte_size(ChanBin)),

Replacement in src/posts.erl at line 78 [11.5381]

B:BD[15.2161] → [15.2161:2216]

    {NumLinks, Rest} = wire:decode_varint(SignedData),

[15.2161]

[8.12966]

    {NumLinks, Rest} = cabal_wire:decode_varint(SignedData),

Replacement in src/posts.erl at line 88 [11.5381]

B:BD[15.2560] → [15.2560:2637]

            [PostType, Timestamp, PostBody] = wire:decode_varints(Rest2, 2),

[15.2560]

[15.2637]

            [PostType, Timestamp, PostBody] = cabal_wire:decode_varints(Rest2, 2),

Replacement in src/posts.erl at line 103 [11.5381]

B:BD[16.2736] → [8.13443:13494]

    {ChannelLen, Rest} = wire:decode_varint(Body),

[16.2736]

[8.13494]

    {ChannelLen, Rest} = cabal_wire:decode_varint(Body),

Replacement in src/posts.erl at line 105 [11.5381]

B:BD[8.13552] → [8.13552:13602]

    {TextLen, Rest3} = wire:decode_varint(Rest2),

[8.13552]

[8.13602]

    {TextLen, Rest3} = cabal_wire:decode_varint(Rest2),

Replacement in src/posts.erl at line 110 [11.5381]

B:BD[16.2852] → [8.13712:13762]

    {NumHashes, Rest} = wire:decode_varint(Body),

[16.2852]

[8.13762]

    {NumHashes, Rest} = cabal_wire:decode_varint(Body),

Replacement in src/posts.erl at line 116 [11.5381]

B:BD[16.2904] → [8.13891:13937]

    KVs = wire:decode_list_of_binaries(Body),

[16.2904]

[8.13937]

    KVs = cabal_wire:decode_list_of_binaries(Body),

Replacement in src/posts.erl at line 120 [11.5381]

B:BD[16.2965] → [8.13971:14022]

    {ChannelLen, Rest} = wire:decode_varint(Body),

[16.2965]

[8.14022]

    {ChannelLen, Rest} = cabal_wire:decode_varint(Body),

Replacement in src/posts.erl at line 122 [11.5381]

B:BD[8.14080] → [8.14080:14131]

    {TopicLen, Rest3} = wire:decode_varint(Rest2),

[8.14080]

[8.14131]

    {TopicLen, Rest3} = cabal_wire:decode_varint(Rest2),

Replacement in src/posts.erl at line 127 [11.5381]

B:BD[16.3034] → [8.14215:14266]

    {ChannelLen, Rest} = wire:decode_varint(Body),

[16.3034]

[8.14266]

    {ChannelLen, Rest} = cabal_wire:decode_varint(Body),

Replacement in src/posts.erl at line 132 [11.5381]

B:BD[16.3088] → [8.14337:14388]

    {ChannelLen, Rest} = wire:decode_varint(Body),

[16.3088]

[8.14388]

    {ChannelLen, Rest} = cabal_wire:decode_varint(Body),

Replacement in src/peer.erl at line 485 [18.854]
B:BD[17.10684] → [17.10684:10728]
```
    {ok, Msgs} = wire:split_messages(Data),
```
[17.10684]
[17.10728]
```
    {ok, Msgs} = cabal_wire:split_messages(Data),
```
Replacement in src/peer.erl at line 487 [18.854]
B:BD[17.10756] → [17.10756:10796]
```
        {ok, Msg} = wire:decode(Chunk),
```
[17.10756]
[17.10796]
```
        {ok, Msg} = cabal_wire:decode(Chunk),
```
Replacement in src/peer.erl at line 1376 [18.854]
∅:D[8.26439] → [19.12050:12109]
B:BD[20.4294] → [19.12050:12109]
```
    Binary = wire:encode_cancel_request(Header, CancelId),
```
[8.26439]
[3.7989]
```
    Binary = cabal_wire:encode_cancel_request(Header, CancelId),
```

Replacement in src/peer.erl at line 1390 [18.854]

∅:D[8.26544] → [19.12268:12341]

B:BD[20.4608] → [19.12268:12341]

    Binary = wire:encode_channel_state_request(Header, Channel, Future),

[8.26544]

[3.8229]

    Binary = cabal_wire:encode_channel_state_request(Header, Channel, Future),

Replacement in src/peer.erl at line 1404 [18.854]

∅:D[8.26649] → [21.6131:6220]

B:BD[21.6131] → [21.6131:6220]

    Binary = wire:encode_channel_time_range_request(Header, Channel, Start, End, Limit),

[8.26649]

[3.8490]

    Binary = cabal_wire:encode_channel_time_range_request(Header, Channel, Start, End, Limit),

Replacement in src/peer.erl at line 1418 [18.854]
∅:D[8.26899] → [19.12530:12585]
B:BD[19.12530] → [19.12530:12585]
```
    Binary = wire:encode_post_request(Header, Hashes),
```
[8.26899]
[3.8717]
```
    Binary = cabal_wire:encode_post_request(Header, Hashes),
```

Replacement in src/peer.erl at line 1432 [18.854]

B:BD[22.6480] → [22.6480:6550]

    Binary = wire:encode_channel_list_request(Header, Offset, Limit),

[22.6480]

[3.8974]

    Binary = cabal_wire:encode_channel_list_request(Header, Offset, Limit),

Replacement in src/peer.erl at line 1444 [18.854]

∅:D[8.26986] → [19.12768:12834]

B:BD[19.12768] → [19.12768:12834]

    Binary = wire:encode_channel_list_response(Header, Channels),

[8.26986]

[3.9197]

    Binary = cabal_wire:encode_channel_list_response(Header, Channels),

Replacement in src/peer.erl at line 1456 [18.854]
∅:D[8.27217] → [14.13032:13087]
B:BD[14.13032] → [14.13032:13087]
```
    Binary = wire:encode_post_response(Header, Posts),
```
[8.27217]
[3.9430]
```
    Binary = cabal_wire:encode_post_response(Header, Posts),
```
Replacement in src/peer.erl at line 1468 [18.854]
∅:D[8.27450] → [23.5537:5593]
B:BD[23.5537] → [23.5537:5593]
```
    Binary = wire:encode_hash_response(Header, Hashes),
```
[8.27450]
[3.9666]
```
    Binary = cabal_wire:encode_hash_response(Header, Hashes),
```

Replacement in src/peer.erl at line 1486 [18.854]

B:BD[19.13050] → [19.13050:13102]

    {MsgLen, Payload} = wire:decode_varint(Binary),

[19.13050]

[19.13102]

    {MsgLen, Payload} = cabal_wire:decode_varint(Binary),

Replacement in src/peer.erl at line 1491 [18.854]

B:BD[19.13230] → [19.13230:13276]

            {ok, Msg} = wire:decode(Payload),

[19.13230]

[17.14863]

            {ok, Msg} = cabal_wire:decode(Payload),

File move: wire.erl → cabal_wire.erl
BF:BFD[2.7] → [2.24:56]
BF:BF[2.56] → [6.5336:5336]
[2.7]
[6.5336]
Replacement in src/cabal_wire.erl at line 5 [6.5336]
∅:D[24.565] → [6.5337:5352]
B:BD[6.5336] → [6.5337:5352]
```
-module(wire).
```
[24.565]
[6.5352]
```
-module(cabal_wire).
```