diff --git a/contracts/cultmesh/content-vectors.cs-written.json b/contracts/cultmesh/content-vectors.cs-written.json new file mode 100644 index 00000000..30a139ed --- /dev/null +++ b/contracts/cultmesh/content-vectors.cs-written.json @@ -0,0 +1,64 @@ +{ + "vectors": [ + { + "label": "answer_found.request", + "kind": "request", + "messagePackBase64": "ha1zY2hlbWFWZXJzaW9u2SFjdWx0bWVzaC5jb250ZW50X2NodW5rX3JlcXVlc3QudjGpbWVzc2FnZUlkrHZlY3Rvci1mb3VuZKljaHVua0hhc2jZR1NIQTI1Njo1OTkzYWM2MDQwN2U4NjYwMTg3M2JjMzhlZTZmOGRiM2VhOTEyZTk4NzYxY2I1NThhYjk3OTVkYjMwNmI0NzRjqXJlY29yZEtledlPbWVzaDpjZG46Y2h1bms6NTk5M2FjNjA0MDdlODY2MDE4NzNiYzM4ZWU2ZjhkYjNlYTkxMmU5ODc2MWNiNTU4YWI5Nzk1ZGIzMDZiNDc0Y7FleHBlY3RlZFNpemVCeXRlc80S3w==" + }, + { + "label": "answer_found.response", + "kind": "response", + "messagePackBase64": "h61zY2hlbWFWZXJzaW9u2SJjdWx0bWVzaC5jb250ZW50X2NodW5rX3Jlc3BvbnNlLnYxqW1lc3NhZ2VJZKx2ZWN0b3ItZm91bmSlZm91bmTDqWNodW5rSGFzaNlANTk5M2FjNjA0MDdlODY2MDE4NzNiYzM4ZWU2ZjhkYjNlYTkxMmU5ODc2MWNiNTU4YWI5Nzk1ZGIzMDZiNDc0Y6lzaXplQnl0ZXPNEt\u002BncGF5bG9hZMUS3/n6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5OjulZXJyb3Kg" + }, + { + "label": "answer_not_found.request", + "kind": "request", + "messagePackBase64": "ha1zY2hlbWFWZXJzaW9u2SFjdWx0bWVzaC5jb250ZW50X2NodW5rX3JlcXVlc3QudjGpbWVzc2FnZUlkrnZlY3Rvci1taXNzaW5nqWNodW5rSGFzaNlAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMKlyZWNvcmRLZXmgsWV4cGVjdGVkU2l6ZUJ5dGVzZA==" + }, + { + "label": "answer_not_found.response", + "kind": "response", + "messagePackBase64": "h61zY2hlbWFWZXJzaW9u2SJjdWx0bWVzaC5jb250ZW50X2NodW5rX3Jlc3BvbnNlLnYxqW1lc3NhZ2VJZK52ZWN0b3ItbWlzc2luZ6Vmb3VuZMKpY2h1bmtIYXNo2UAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwqXNpemVCeXRlcwCncGF5bG9hZMQApWVycm9y2TZGaWxlTm90Rm91bmRFeGNlcHRpb246IENvbnRlbnQgY2h1bmsgaXMgbm90IGF2YWlsYWJsZS4=" + }, + { + "label": "answer_record_key_disagrees.request", + "kind": "request", + "messagePackBase64": "ha1zY2hlbWFWZXJzaW9u2SFjdWx0bWVzaC5jb250ZW50X2NodW5rX3JlcXVlc3QudjGpbWVzc2FnZUlkqnZlY3Rvci1rZXmpY2h1bmtIYXNo2UA1OTkzYWM2MDQwN2U4NjYwMTg3M2JjMzhlZTZmOGRiM2VhOTEyZTk4NzYxY2I1NThhYjk3OTVkYjMwNmI0NzRjqXJlY29yZEtlebRtZXNoOmNkbjpjaHVuazpvdGhlcrFleHBlY3RlZFNpemVCeXRlc80S3w==" + }, + { + "label": "answer_record_key_disagrees.response", + "kind": "response", + "messagePackBase64": "h61zY2hlbWFWZXJzaW9u2SJjdWx0bWVzaC5jb250ZW50X2NodW5rX3Jlc3BvbnNlLnYxqW1lc3NhZ2VJZKp2ZWN0b3Ita2V5pWZvdW5kwqljaHVua0hhc2jZQDU5OTNhYzYwNDA3ZTg2NjAxODczYmMzOGVlNmY4ZGIzZWE5MTJlOTg3NjFjYjU1OGFiOTc5NWRiMzA2YjQ3NGOpc2l6ZUJ5dGVzAKdwYXlsb2FkxAClZXJyb3LZT0ludmFsaWREYXRhRXhjZXB0aW9uOiBDb250ZW50IGNodW5rIHJlY29yZCBrZXkgZGlzYWdyZWVzIHdpdGggaXRzIGNvbnRlbnQgaGFzaC4=" + }, + { + "label": "answer_size_mismatch.request", + "kind": "request", + "messagePackBase64": "ha1zY2hlbWFWZXJzaW9u2SFjdWx0bWVzaC5jb250ZW50X2NodW5rX3JlcXVlc3QudjGpbWVzc2FnZUlkq3ZlY3Rvci1zaXplqWNodW5rSGFzaNlANTk5M2FjNjA0MDdlODY2MDE4NzNiYzM4ZWU2ZjhkYjNlYTkxMmU5ODc2MWNiNTU4YWI5Nzk1ZGIzMDZiNDc0Y6lyZWNvcmRLZXnZT21lc2g6Y2RuOmNodW5rOjU5OTNhYzYwNDA3ZTg2NjAxODczYmMzOGVlNmY4ZGIzZWE5MTJlOTg3NjFjYjU1OGFiOTc5NWRiMzA2YjQ3NGOxZXhwZWN0ZWRTaXplQnl0ZXPNEt4=" + }, + { + "label": "answer_size_mismatch.response", + "kind": "response", + "messagePackBase64": "h61zY2hlbWFWZXJzaW9u2SJjdWx0bWVzaC5jb250ZW50X2NodW5rX3Jlc3BvbnNlLnYxqW1lc3NhZ2VJZKt2ZWN0b3Itc2l6ZaVmb3VuZMKpY2h1bmtIYXNo2UA1OTkzYWM2MDQwN2U4NjYwMTg3M2JjMzhlZTZmOGRiM2VhOTEyZTk4NzYxY2I1NThhYjk3OTVkYjMwNmI0NzRjqXNpemVCeXRlcwCncGF5bG9hZMQApWVycm9y2WBJbnZhbGlkRGF0YUV4Y2VwdGlvbjogQ0ROIGFydGlmYWN0IGNodW5rIHBheWxvYWQgbWV0YWRhdGEgZG9lcyBub3QgbWF0Y2ggaXRzIG1hbmlmZXN0IHJlZmVyZW5jZS4=" + }, + { + "label": "response_hash_last_digit", + "kind": "response", + "messagePackBase64": "h61zY2hlbWFWZXJzaW9u2SJjdWx0bWVzaC5jb250ZW50X2NodW5rX3Jlc3BvbnNlLnYxqW1lc3NhZ2VJZKx2ZWN0b3ItZGlnaXSlZm91bmTDqWNodW5rSGFzaNlANTk5M2FjNjA0MDdlODY2MDE4NzNiYzM4ZWU2ZjhkYjNlYTkxMmU5ODc2MWNiNTU4YWI5Nzk1ZGIzMDZiNDc0MKlzaXplQnl0ZXPNEt\u002BncGF5bG9hZMUS3/n6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1\u002Bf4CBgoOEhYaHiImKi4yNjo\u002BQkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3\u002BDh4uPk5ebn6Onq6\u002Bzt7u/w8fLz9PX29/j5\u002BgABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp\u002BgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2\u002Bv8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4\u002BTl5ufo6err7O3u7/Dx8vP09fb3\u002BPn6AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\u002BP0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\u002BAgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\u002BwsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5\u002Bjp6uvs7e7v8PHy8/T19vf4\u002BfoAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5OjulZXJyb3Kg" + }, + { + "label": "manifest", + "kind": "manifest", + "messagePackBase64": "mrVldXJla2EvY29udGVudC12ZWN0b3KlYXNzZXShMdlAZjRhZTJhN2M5NWY0ZDk2NjA1OGY3NWMxMzE4NWFhMGFiNmE5MWZjNWFmYWQ4ODYyOTZlZjJhZWU3NTVhMmFmMc4AFBLfvGFwcGxpY2F0aW9uL3gtY3VsdG5ldC12ZWN0b3LZITIwMjYtMDktMjJUMDA6MDA6MDAuMDAwMDAwMCswMDowMJaU2UAzMWExZjlkZWEwMTY5NTUxMDkyZDA1ZThiZjRhNDQ2MjI4YzhjM2ViNGM5YjcxM2M2NmFkY2I3ZmQ1M2M4OWJlAM4ABAAA2U9tZXNoOmNkbjpjaHVuazozMWExZjlkZWEwMTY5NTUxMDkyZDA1ZThiZjRhNDQ2MjI4YzhjM2ViNGM5YjcxM2M2NmFkY2I3ZmQ1M2M4OWJllNlAZTMxYmRjNjM1NzdmZTc2ZjY0NDEwMTRhYWFhMjIyNmQ5ZmZjZTExYjQ0ZDBkNTEwY2FkZTEzMmI3OWZkN2Q3Ns4ABAAAzgAEAADZT21lc2g6Y2RuOmNodW5rOmUzMWJkYzYzNTc3ZmU3NmY2NDQxMDE0YWFhYTIyMjZkOWZmY2UxMWI0NGQwZDUxMGNhZGUxMzJiNzlmZDdkNzaU2UBjN2YxYmRlOWUxZWZhN2QxMzg1ZDUxYjA3N2VhODdiMGMzODYwZDI4ZGE0M2Q1ZDZmMjIxZTg0NWM0YzIzNjBmzgAIAADOAAQAANlPbWVzaDpjZG46Y2h1bms6YzdmMWJkZTllMWVmYTdkMTM4NWQ1MWIwNzdlYTg3YjBjMzg2MGQyOGRhNDNkNWQ2ZjIyMWU4NDVjNGMyMzYwZpTZQGFhMTQ0NGJlNGI2NDA5OGY1ZGQ4NjNiNWIwYWM1NjE0ODBiM2ZiNWM0MWZjMDdjZjUwYTYyZWRjOTQxMjRiY2POAAwAAM4ABAAA2U9tZXNoOmNkbjpjaHVuazphYTE0NDRiZTRiNjQwOThmNWRkODYzYjViMGFjNTYxNDgwYjNmYjVjNDFmYzA3Y2Y1MGE2MmVkYzk0MTI0YmNjlNlAMjgzMTcxNTg1OWYwMWYzZjk2M2RkMGYxMTk0ZGJkYmI3NjA5OTk3NDIzMDE1ZDMxZjYwNzkxMWUxYmY4NjQwMs4AEAAAzgAEAADZT21lc2g6Y2RuOmNodW5rOjI4MzE3MTU4NTlmMDFmM2Y5NjNkZDBmMTE5NGRiZGJiNzYwOTk5NzQyMzAxNWQzMWY2MDc5MTFlMWJmODY0MDKU2UA1OTkzYWM2MDQwN2U4NjYwMTg3M2JjMzhlZTZmOGRiM2VhOTEyZTk4NzYxY2I1NThhYjk3OTVkYjMwNmI0NzRjzgAUAADNEt/ZT21lc2g6Y2RuOmNodW5rOjU5OTNhYzYwNDA3ZTg2NjAxODczYmMzOGVlNmY4ZGIzZWE5MTJlOTg3NjFjYjU1OGFiOTc5NWRiMzA2YjQ3NGOQgA==" + }, + { + "label": "manifest_out_of_order", + "kind": "manifest", + "messagePackBase64": "mrVldXJla2EvY29udGVudC12ZWN0b3KlYXNzZXShMdlAZjRhZTJhN2M5NWY0ZDk2NjA1OGY3NWMxMzE4NWFhMGFiNmE5MWZjNWFmYWQ4ODYyOTZlZjJhZWU3NTVhMmFmMc4AFBLfvGFwcGxpY2F0aW9uL3gtY3VsdG5ldC12ZWN0b3LZITIwMjYtMDktMjJUMDA6MDA6MDAuMDAwMDAwMCswMDowMJaU2UBhYTE0NDRiZTRiNjQwOThmNWRkODYzYjViMGFjNTYxNDgwYjNmYjVjNDFmYzA3Y2Y1MGE2MmVkYzk0MTI0YmNjzgAMAADOAAQAANlPbWVzaDpjZG46Y2h1bms6YWExNDQ0YmU0YjY0MDk4ZjVkZDg2M2I1YjBhYzU2MTQ4MGIzZmI1YzQxZmMwN2NmNTBhNjJlZGM5NDEyNGJjY5TZQDMxYTFmOWRlYTAxNjk1NTEwOTJkMDVlOGJmNGE0NDYyMjhjOGMzZWI0YzliNzEzYzY2YWRjYjdmZDUzYzg5YmUAzgAEAADZT21lc2g6Y2RuOmNodW5rOjMxYTFmOWRlYTAxNjk1NTEwOTJkMDVlOGJmNGE0NDYyMjhjOGMzZWI0YzliNzEzYzY2YWRjYjdmZDUzYzg5YmWU2UA1OTkzYWM2MDQwN2U4NjYwMTg3M2JjMzhlZTZmOGRiM2VhOTEyZTk4NzYxY2I1NThhYjk3OTVkYjMwNmI0NzRjzgAUAADNEt/ZT21lc2g6Y2RuOmNodW5rOjU5OTNhYzYwNDA3ZTg2NjAxODczYmMzOGVlNmY4ZGIzZWE5MTJlOTg3NjFjYjU1OGFiOTc5NWRiMzA2YjQ3NGOU2UBlMzFiZGM2MzU3N2ZlNzZmNjQ0MTAxNGFhYWEyMjI2ZDlmZmNlMTFiNDRkMGQ1MTBjYWRlMTMyYjc5ZmQ3ZDc2zgAEAADOAAQAANlPbWVzaDpjZG46Y2h1bms6ZTMxYmRjNjM1NzdmZTc2ZjY0NDEwMTRhYWFhMjIyNmQ5ZmZjZTExYjQ0ZDBkNTEwY2FkZTEzMmI3OWZkN2Q3NpTZQDI4MzE3MTU4NTlmMDFmM2Y5NjNkZDBmMTE5NGRiZGJiNzYwOTk5NzQyMzAxNWQzMWY2MDc5MTFlMWJmODY0MDLOABAAAM4ABAAA2U9tZXNoOmNkbjpjaHVuazoyODMxNzE1ODU5ZjAxZjNmOTYzZGQwZjExOTRkYmRiYjc2MDk5OTc0MjMwMTVkMzFmNjA3OTExZTFiZjg2NDAylNlAYzdmMWJkZTllMWVmYTdkMTM4NWQ1MWIwNzdlYTg3YjBjMzg2MGQyOGRhNDNkNWQ2ZjIyMWU4NDVjNGMyMzYwZs4ACAAAzgAEAADZT21lc2g6Y2RuOmNodW5rOmM3ZjFiZGU5ZTFlZmE3ZDEzODVkNTFiMDc3ZWE4N2IwYzM4NjBkMjhkYTQzZDVkNmYyMjFlODQ1YzRjMjM2MGaQgA==" + }, + { + "label": "manifest_empty_body", + "kind": "manifest", + "messagePackBase64": "mrVldXJla2EvY29udGVudC12ZWN0b3KlYXNzZXShMdlAZTNiMGM0NDI5OGZjMWMxNDlhZmJmNGM4OTk2ZmI5MjQyN2FlNDFlNDY0OWI5MzRjYTQ5NTk5MWI3ODUyYjg1NQC8YXBwbGljYXRpb24veC1jdWx0bmV0LXZlY3RvctkhMjAyNi0wOS0yMlQwMDowMDowMC4wMDAwMDAwKzAwOjAwkZTZQGUzYjBjNDQyOThmYzFjMTQ5YWZiZjRjODk5NmZiOTI0MjdhZTQxZTQ2NDliOTM0Y2E0OTU5OTFiNzg1MmI4NTUAANlPbWVzaDpjZG46Y2h1bms6ZTNiMGM0NDI5OGZjMWMxNDlhZmJmNGM4OTk2ZmI5MjQyN2FlNDFlNDY0OWI5MzRjYTQ5NTk5MWI3ODUyYjg1NZCA" + } + ] +} diff --git a/packages/cultnet-rs/tests/content.rs b/packages/cultnet-rs/tests/content.rs new file mode 100644 index 00000000..363a600d --- /dev/null +++ b/packages/cultnet-rs/tests/content.rs @@ -0,0 +1,520 @@ +//! The content plane (`src/content.rs`, the two chunk messages in `src/contracts.rs`), pinned against +//! the C# reference. `contracts/cultmesh/content-vectors.cs-written.json` is the reference's own +//! bytes (written by `CultMeshContentVectorTests`, including the answers `CultMeshLegacyRudpContentServer` +//! gives); `content-vectors.rs-written.json` is this binary's mirror, regenerated with +//! `CULTNET_WRITE_VECTORS=1`, and judged by the C# side. + +use std::collections::HashMap; +use std::path::{Path, PathBuf}; + +use anyhow::Result; +use base64::Engine; +use cultnet_rs::{ + CultMeshCdnArtifactManifest, CultNetMessage, CultNetWireContract, answer_content_chunk_request, + decode_cultnet_message_from_slice, encode_cultnet_message_for_wire, encode_cultnet_message_to_vec, + fetch_content, normalize_hash, pack_content, validate_manifest, +}; +use serde::{Deserialize, Serialize}; + +const CHUNK: usize = 262_144; +const BODY_LEN: usize = 1_315_551; +const CREATED: &str = "2026-09-22T00:00:00.0000000+00:00"; +const SCHEMA_V0: CultNetWireContract = CultNetWireContract::CultNetSchemaV0; + +fn body() -> Vec { + (0..BODY_LEN).map(|i| (i % 251) as u8).collect() +} + +fn pack(bytes: &[u8]) -> (CultMeshCdnArtifactManifest, Vec) { + pack_content( + "eureka/content-vector", + "asset", + "1", + "application/x-cultnet-vector", + CREATED, + bytes, + CHUNK, + ) + .expect("packs") +} + +fn store(chunks: &[cultnet_rs::CultMeshCdnChunk]) -> HashMap> { + chunks + .iter() + .map(|chunk| (chunk.chunk_hash.clone(), chunk.payload.clone())) + .collect() +} + +fn lookup_in<'a>(store: &'a HashMap>) -> impl Fn(&str) -> Option<&'a [u8]> { + move |hash| store.get(hash).map(Vec::as_slice) +} + +fn wire(message: &CultNetMessage) -> Vec { + encode_cultnet_message_to_vec(message, SCHEMA_V0).expect("encodes") +} + +fn unwire(bytes: &[u8]) -> Result { + decode_cultnet_message_from_slice(bytes, SCHEMA_V0) +} + +fn manifest_bytes(manifest: &CultMeshCdnArtifactManifest) -> Vec { + rmp_serde::to_vec_named(manifest).expect("encodes") +} + +fn request(id: &str, hash: &str, key: &str, size: i32) -> CultNetMessage { + CultNetMessage::ContentChunkRequest { + message_id: id.to_string(), + chunk_hash: hash.to_string(), + record_key: key.to_string(), + expected_size_bytes: size, + } +} + +fn response_of(message: &CultNetMessage) -> (&str, bool, &str, &[u8], &str) { + match message { + CultNetMessage::ContentChunkResponse { + message_id, + found, + chunk_hash, + payload, + error, + .. + } => (message_id, *found, chunk_hash, payload, error), + other => panic!("not a content chunk response: {other:?}"), + } +} + +/// A transport closure that answers from `chunks` through the wire, counting calls. +fn serving<'a>( + chunks: &'a HashMap>, + calls: &'a std::cell::Cell, +) -> impl FnMut(CultNetMessage) -> Result + 'a { + move |message| { + calls.set(calls.get() + 1); + let request = unwire(&wire(&message))?; + unwire(&wire(&answer_content_chunk_request(&request, lookup_in(chunks)))) + } +} + +fn flip_last_digit(hash: &str) -> String { + let last = if hash.ends_with('0') { '1' } else { '0' }; + format!("{}{last}", &hash[..hash.len() - 1]) +} + +// ------------------------------------------------------------------------------------------ +// Vector files +// ------------------------------------------------------------------------------------------ + +#[derive(Serialize, Deserialize)] +struct VectorFile { + vectors: Vec, +} + +#[derive(Serialize, Deserialize)] +struct VectorEntry { + label: String, + kind: String, + #[serde(rename = "messagePackBase64")] + message_pack_base64: String, +} + +struct Vector { + label: String, + kind: &'static str, + bytes: Vec, +} + +fn vector_path(name: &str) -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")) + .join("..") + .join("..") + .join("contracts") + .join("cultmesh") + .join(name) +} + +fn read_vectors(name: &str) -> Vec<(String, String, Vec)> { + let path = vector_path(name); + let text = std::fs::read_to_string(&path).unwrap_or_else(|_| { + panic!("{} is missing - write it first (CULTNET_WRITE_VECTORS=1)", path.display()) + }); + let file: VectorFile = serde_json::from_str(&text).expect("vector file parses"); + assert!(!file.vectors.is_empty(), "the vector file must carry at least one vector"); + file.vectors + .into_iter() + .map(|v| { + let bytes = base64::engine::general_purpose::STANDARD + .decode(&v.message_pack_base64) + .expect("base64"); + (v.label, v.kind, bytes) + }) + .collect() +} + +/// The vectors this runtime writes: the same labelled set the C# writer produces, built from Rust +/// values and answered by Rust's `answer_content_chunk_request`. +fn local_vectors() -> Vec { + let (manifest, chunks) = pack(&body()); + let store = store(&chunks); + let last = chunks.last().expect("chunks"); + let last_size = last.payload.len() as i32; + let key = format!("mesh:cdn:chunk:{}", last.chunk_hash); + let mut vectors = Vec::new(); + let mut push_message = |label: String, kind: &'static str, message: &CultNetMessage| { + vectors.push(Vector { label, kind, bytes: wire(message) }); + }; + let answers = [ + ("answer_found", request("vector-found", &format!("SHA256:{}", last.chunk_hash), &key, last_size)), + ("answer_not_found", request("vector-missing", &"0".repeat(64), "", 100)), + ( + "answer_record_key_disagrees", + request("vector-key", &last.chunk_hash, "mesh:cdn:chunk:other", last_size), + ), + ("answer_size_mismatch", request("vector-size", &last.chunk_hash, &key, last_size - 1)), + ]; + for (name, request) in &answers { + push_message(format!("{name}.request"), "request", request); + let answer = answer_content_chunk_request(request, lookup_in(&store)); + push_message(format!("{name}.response"), "response", &answer); + } + push_message( + "response_hash_last_digit".to_string(), + "response", + &CultNetMessage::ContentChunkResponse { + message_id: "vector-digit".to_string(), + found: true, + chunk_hash: flip_last_digit(&last.chunk_hash), + size_bytes: last_size, + payload: last.payload.clone(), + error: String::new(), + }, + ); + let mut push_manifest = |label: &str, manifest: &CultMeshCdnArtifactManifest| { + vectors.push(Vector { + label: label.to_string(), + kind: "manifest", + bytes: manifest_bytes(manifest), + }); + }; + push_manifest("manifest", &manifest); + let mut shuffled = manifest.clone(); + shuffled.chunks = [3, 0, 5, 1, 4, 2].iter().map(|&i| manifest.chunks[i].clone()).collect(); + push_manifest("manifest_out_of_order", &shuffled); + push_manifest("manifest_empty_body", &pack(&[]).0); + vectors +} + +fn to_json(vectors: &[Vector]) -> String { + let file = VectorFile { + vectors: vectors + .iter() + .map(|v| VectorEntry { + label: v.label.clone(), + kind: v.kind.to_string(), + message_pack_base64: base64::engine::general_purpose::STANDARD.encode(&v.bytes), + }) + .collect(), + }; + serde_json::to_string_pretty(&file).expect("serializes") +} + +/// The committed rs-written file is what this binary encodes now. Under `CULTNET_WRITE_VECTORS=1` +/// it is rewritten instead, for the C# test `RustVectorsDecodeInTheReference` to judge. +#[test] +fn rust_written_vectors_are_current() { + let fresh = local_vectors(); + let path = vector_path("content-vectors.rs-written.json"); + if std::env::var("CULTNET_WRITE_VECTORS").as_deref() == Ok("1") { + std::fs::write(&path, to_json(&fresh)).expect("writes the vector file"); + return; + } + let committed = read_vectors("content-vectors.rs-written.json"); + assert_eq!(committed.len(), fresh.len()); + for ((label, kind, bytes), fresh) in committed.iter().zip(&fresh) { + assert_eq!((label.as_str(), kind.as_str()), (fresh.label.as_str(), fresh.kind)); + assert_eq!(bytes, &fresh.bytes, "vector '{label}' drifted from this binary's encode"); + } +} + +/// Byte identity, both ways, against the reference's own bytes: every vector the reference wrote +/// decodes here and this runtime's independently built value encodes to exactly those bytes. The +/// manifest vector also pins `pack_content` (same body and options, same manifest, byte for byte). +#[test] +fn reference_vectors_encode_byte_identically() { + let local = local_vectors(); + let reference = read_vectors("content-vectors.cs-written.json"); + assert_eq!( + reference.iter().map(|(l, _, _)| l.as_str()).collect::>(), + local.iter().map(|v| v.label.as_str()).collect::>(), + "both runtimes write the same labelled vectors" + ); + for ((label, kind, reference_bytes), mine) in reference.iter().zip(&local) { + assert_eq!(reference_bytes, &mine.bytes, "vector '{label}' is not byte identical"); + match kind.as_str() { + "request" | "response" => { + let decoded = unwire(reference_bytes).expect("the reference's bytes decode"); + assert_eq!(&wire(&decoded), reference_bytes, "vector '{label}' does not re-encode identically"); + } + "manifest" => { + let decoded: CultMeshCdnArtifactManifest = + rmp_serde::from_slice(reference_bytes).expect("the reference's manifest decodes"); + assert_eq!(&manifest_bytes(&decoded), reference_bytes, "manifest '{label}' does not re-encode identically"); + } + other => panic!("unknown vector kind {other}"), + } + } +} + +/// F1's failure mode: a chunk response carries `bin`, which the JSON-value path cannot carry. +#[test] +fn a_chunk_response_carries_bin_through_the_raw_path() { + let payload: Vec = (0..=255u8).collect(); + let message = CultNetMessage::ContentChunkResponse { + message_id: "m".to_string(), + found: true, + chunk_hash: "ab".to_string(), + size_bytes: 256, + payload: payload.clone(), + error: String::new(), + }; + let wire_value = encode_cultnet_message_for_wire(&message, SCHEMA_V0).expect("encodes"); + let entries = wire_value.as_map().expect("a map"); + let (_, value) = entries.iter().find(|(k, _)| k.as_str() == Some("payload")).expect("payload key"); + assert!(matches!(value, rmpv::Value::Binary(bytes) if *bytes == payload), "payload must be bin"); + assert_eq!(unwire(&wire(&message)).expect("decodes"), message); +} + +#[test] +fn normalize_hash_matches_the_reference() { + for (input, expected) in [ + ("SHA256:ABCdef", "abcdef"), + ("sha256:abc", "abc"), + ("sha256: ABC ", "abc"), + (" ABC ", "abc"), + (" sha256:abc", "sha256:abc"), + ("sha256:", ""), + ("plain", "plain"), + ] { + assert_eq!(normalize_hash(input).expect("normalizes"), expected, "input {input:?}"); + } + for blank in ["", " "] { + assert!(normalize_hash(blank).is_err(), "{blank:?} must be refused"); + } + // The fixture's uppercase-prefix request names the same chunk as its bare hash. + let reference = read_vectors("content-vectors.cs-written.json"); + let (_, _, bytes) = reference.iter().find(|(l, _, _)| l == "answer_found.request").expect("vector"); + let CultNetMessage::ContentChunkRequest { chunk_hash, .. } = unwire(bytes).expect("decodes") else { + panic!("not a request"); + }; + assert!(chunk_hash.starts_with("SHA256:")); + let (_, chunks) = pack(&body()); + assert_eq!(normalize_hash(&chunk_hash).expect("normalizes"), chunks.last().unwrap().chunk_hash); +} + +#[test] +fn a_manifest_out_of_offset_order_is_accepted_as_the_reference_accepts_it() { + let reference = read_vectors("content-vectors.cs-written.json"); + let (_, _, bytes) = reference.iter().find(|(l, _, _)| l == "manifest_out_of_order").expect("vector"); + let manifest: CultMeshCdnArtifactManifest = rmp_serde::from_slice(bytes).expect("decodes"); + assert_ne!(manifest.chunks[0].offset, 0, "the fixture's chunk list is shuffled"); + validate_manifest(&manifest).expect("the reference accepts it"); + let (_, chunks) = pack(&body()); + let store = store(&chunks); + let calls = std::cell::Cell::new(0); + let fetched = fetch_content(&manifest, BODY_LEN as u64, serving(&store, &calls)).expect("fetches"); + assert_eq!(fetched, body()); + assert_eq!(calls.get(), 6); +} + +#[test] +fn a_hostile_manifest_is_refused_before_any_request() { + let (good, chunks) = pack(&body()); + let store = store(&chunks); + let mut hostile = Vec::new(); + let mut negative = good.clone(); + negative.size_bytes = -1; + hostile.push(negative); + let mut gap = good.clone(); + gap.chunks[2].offset += 1; + hostile.push(gap); + let mut overlap = good.clone(); + overlap.chunks[3].offset -= 1; + hostile.push(overlap); + let mut short = good.clone(); + short.size_bytes -= 1; + hostile.push(short); + let mut negative_chunk = good.clone(); + negative_chunk.chunks[5].size_bytes = -4831; + hostile.push(negative_chunk); + for manifest in hostile { + let calls = std::cell::Cell::new(0); + assert!(fetch_content(&manifest, u64::MAX, serving(&store, &calls)).is_err()); + assert_eq!(calls.get(), 0, "a corrupt manifest must not make the client ask"); + } +} + +#[test] +fn a_manifest_over_the_cap_is_refused_before_any_request() { + let (manifest, chunks) = pack(&body()); + let store = store(&chunks); + let size = BODY_LEN as u64; + + let calls = std::cell::Cell::new(0); + let fetched = fetch_content(&manifest, size, serving(&store, &calls)).expect("exactly the cap is accepted"); + assert_eq!(fetched.len(), BODY_LEN); + assert_eq!(calls.get(), 6); + + // One byte over, and sizes where doubling the cap would admit the body. + for cap in [size - 1, size / 2 + 1, size / 2, 0] { + let calls = std::cell::Cell::new(0); + assert!(fetch_content(&manifest, cap, serving(&store, &calls)).is_err(), "cap {cap} must refuse"); + assert_eq!(calls.get(), 0, "cap {cap} must refuse before any request"); + } +} + +#[test] +fn a_chunk_whose_hash_differs_in_the_last_digit_is_refused() { + let reference = read_vectors("content-vectors.cs-written.json"); + let (_, _, bytes) = reference.iter().find(|(l, _, _)| l == "response_hash_last_digit").expect("vector"); + let CultNetMessage::ContentChunkResponse { chunk_hash: claimed, payload, .. } = unwire(bytes).expect("decodes") else { + panic!("not a response"); + }; + // A one-chunk manifest for exactly that payload: its bytes are right, only the response's claim is off. + let (manifest, chunks) = pack(&payload); + let honest = chunks[0].chunk_hash.clone(); + assert_ne!(claimed, honest); + assert_eq!(claimed[..claimed.len() - 1], honest[..honest.len() - 1], "they differ in the last digit only"); + let error = fetch_content(&manifest, u64::MAX, |message| { + let CultNetMessage::ContentChunkRequest { message_id, .. } = message else { + panic!("not a request"); + }; + let CultNetMessage::ContentChunkResponse { found, size_bytes, payload, error, .. } = + unwire(bytes).expect("decodes") + else { + panic!("not a response"); + }; + Ok(CultNetMessage::ContentChunkResponse { + message_id, + found, + chunk_hash: claimed.clone(), + size_bytes, + payload, + error, + }) + }) + .expect_err("a hash off by one digit is a different hash"); + assert!(error.to_string().contains("does not match its payload"), "{error}"); +} + +#[test] +fn a_body_whose_chunks_verify_but_whole_hash_does_not_is_refused() { + let (mut manifest, chunks) = pack(&body()); + manifest.content_hash = pack(b"another body").0.content_hash; + let store = store(&chunks); + let calls = std::cell::Cell::new(0); + let error = fetch_content(&manifest, u64::MAX, serving(&store, &calls)).expect_err("whole body must verify"); + assert_eq!(calls.get(), 6, "every chunk verified; only the whole body is wrong"); + assert!(error.to_string().contains("content hash"), "{error}"); +} + +#[test] +fn a_response_for_another_message_id_is_refused() { + let (manifest, chunks) = pack(&body()); + let store = store(&chunks); + let error = fetch_content(&manifest, u64::MAX, |message| { + let mut answer = answer_content_chunk_request(&message, lookup_in(&store)); + if let CultNetMessage::ContentChunkResponse { message_id, .. } = &mut answer { + *message_id = "someone-else".to_string(); + } + Ok(answer) + }) + .expect_err("an answer to another request is not this answer"); + assert!(error.to_string().contains("someone-else"), "{error}"); +} + +#[test] +fn an_empty_body_packs_one_zero_length_chunk_and_fetches() { + let (manifest, chunks) = pack(&[]); + assert_eq!((manifest.chunks.len(), chunks.len(), manifest.size_bytes), (1, 1, 0)); + let store = store(&chunks); + let calls = std::cell::Cell::new(0); + assert_eq!(fetch_content(&manifest, 0, serving(&store, &calls)).expect("fetches"), Vec::::new()); + assert_eq!(calls.get(), 1); +} + +#[test] +fn answer_refuses_a_record_key_that_disagrees_with_its_hash() { + let (_, chunks) = pack(&body()); + let store = store(&chunks); + let last = chunks.last().unwrap(); + let asked = std::cell::Cell::new(false); + let answer = answer_content_chunk_request( + &request("m", &last.chunk_hash, "mesh:cdn:chunk:other", last.payload.len() as i32), + |hash| { + asked.set(true); + lookup_in(&store)(hash) + }, + ); + let (id, found, _, payload, error) = response_of(&answer); + assert_eq!((id, found, payload.len()), ("m", false, 0)); + assert_eq!(error, "InvalidDataException: Content chunk record key disagrees with its content hash."); + assert!(!asked.get(), "the key check precedes the lookup, as in HandleAsync"); +} + +/// Every failure is an answer (`found: false`, empty payload, the reference's spelling) and equals, +/// byte for byte, what `CultMeshLegacyRudpContentServer` answered to the same request bytes. +#[test] +fn answer_serves_found_false_with_the_reference_error_spelling() { + let (_, chunks) = pack(&body()); + let store = store(&chunks); + let reference = read_vectors("content-vectors.cs-written.json"); + let mut judged = 0; + for (label, _, request_bytes) in reference.iter().filter(|(l, _, _)| l.ends_with(".request")) { + let name = label.trim_end_matches(".request"); + let request = unwire(request_bytes).expect("decodes"); + let answer = answer_content_chunk_request(&request, lookup_in(&store)); + let (_, _, expected_bytes) = reference + .iter() + .find(|(l, _, _)| *l == format!("{name}.response")) + .expect("paired response"); + assert_eq!(&wire(&answer), expected_bytes, "{name}: answer differs from the reference's"); + let (_, found, _, payload, error) = response_of(&answer); + if name == "answer_found" { + assert!(found && error.is_empty() && !payload.is_empty()); + } else { + assert!(!found && payload.is_empty(), "{name}"); + assert!(error.contains("Exception: "), "{name}: {error}"); + } + judged += 1; + } + assert_eq!(judged, 4); +} + +#[test] +fn content_messages_refuse_what_the_reference_never_produces() { + let refused = |message: CultNetMessage| assert!(encode_cultnet_message_for_wire(&message, SCHEMA_V0).is_err(), "{message:?}"); + refused(request("", "abc", "", 1)); + refused(request("m", "sha256: ", "", 1)); + refused(request("m", "abc", "", -1)); + let response = |found: bool, size: i32, payload: &[u8], error: &str| CultNetMessage::ContentChunkResponse { + message_id: "m".to_string(), + found, + chunk_hash: "abc".to_string(), + size_bytes: size, + payload: payload.to_vec(), + error: error.to_string(), + }; + refused(response(true, 3, &[1, 2], "")); + refused(response(true, 2, &[1, 2], "boom")); + refused(response(false, 0, &[1], "boom")); + assert!(encode_cultnet_message_for_wire(&response(true, 2, &[1, 2], ""), SCHEMA_V0).is_ok()); + assert!(encode_cultnet_message_for_wire(&response(false, 0, &[], "boom"), SCHEMA_V0).is_ok()); +} + +#[test] +fn gamecult_networking_contract_refuses_content_messages() { + let legacy = CultNetWireContract::GameCultNetworkingV0; + let message = request("m", "abc", "", 1); + assert!(encode_cultnet_message_for_wire(&message, legacy).is_err()); + assert!(decode_cultnet_message_from_slice(&wire(&message), legacy).is_err()); +}