@deroll/cmio 0.1.0

package/deps/machine-guest-tools/sys-utils/libcmt/src/merkle.c

@@ -0,0 +1,202 @@
+/* Copyright Cartesi and individual authors (see AUTHORS)
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "libcmt/merkle.h"
+#include "libcmt/util.h"
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+
+// clang-format off
+static const uint8_t pristine_hash[][CMT_KECCAK_LENGTH] = {
+    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+    {0xad,0x32,0x28,0xb6,0x76,0xf7,0xd3,0xcd,0x42,0x84,0xa5,0x44,0x3f,0x17,0xf1,0x96,0x2b,0x36,0xe4,0x91,0xb3,0x0a,0x40,0xb2,0x40,0x58,0x49,0xe5,0x97,0xba,0x5f,0xb5},
+    {0xb4,0xc1,0x19,0x51,0x95,0x7c,0x6f,0x8f,0x64,0x2c,0x4a,0xf6,0x1c,0xd6,0xb2,0x46,0x40,0xfe,0xc6,0xdc,0x7f,0xc6,0x07,0xee,0x82,0x06,0xa9,0x9e,0x92,0x41,0x0d,0x30},
+    {0x21,0xdd,0xb9,0xa3,0x56,0x81,0x5c,0x3f,0xac,0x10,0x26,0xb6,0xde,0xc5,0xdf,0x31,0x24,0xaf,0xba,0xdb,0x48,0x5c,0x9b,0xa5,0xa3,0xe3,0x39,0x8a,0x04,0xb7,0xba,0x85},
+    {0xe5,0x87,0x69,0xb3,0x2a,0x1b,0xea,0xf1,0xea,0x27,0x37,0x5a,0x44,0x09,0x5a,0x0d,0x1f,0xb6,0x64,0xce,0x2d,0xd3,0x58,0xe7,0xfc,0xbf,0xb7,0x8c,0x26,0xa1,0x93,0x44},
+    {0x0e,0xb0,0x1e,0xbf,0xc9,0xed,0x27,0x50,0x0c,0xd4,0xdf,0xc9,0x79,0x27,0x2d,0x1f,0x09,0x13,0xcc,0x9f,0x66,0x54,0x0d,0x7e,0x80,0x05,0x81,0x11,0x09,0xe1,0xcf,0x2d},
+    {0x88,0x7c,0x22,0xbd,0x87,0x50,0xd3,0x40,0x16,0xac,0x3c,0x66,0xb5,0xff,0x10,0x2d,0xac,0xdd,0x73,0xf6,0xb0,0x14,0xe7,0x10,0xb5,0x1e,0x80,0x22,0xaf,0x9a,0x19,0x68},
+    {0xff,0xd7,0x01,0x57,0xe4,0x80,0x63,0xfc,0x33,0xc9,0x7a,0x05,0x0f,0x7f,0x64,0x02,0x33,0xbf,0x64,0x6c,0xc9,0x8d,0x95,0x24,0xc6,0xb9,0x2b,0xcf,0x3a,0xb5,0x6f,0x83},
+    {0x98,0x67,0xcc,0x5f,0x7f,0x19,0x6b,0x93,0xba,0xe1,0xe2,0x7e,0x63,0x20,0x74,0x24,0x45,0xd2,0x90,0xf2,0x26,0x38,0x27,0x49,0x8b,0x54,0xfe,0xc5,0x39,0xf7,0x56,0xaf},
+    {0xce,0xfa,0xd4,0xe5,0x08,0xc0,0x98,0xb9,0xa7,0xe1,0xd8,0xfe,0xb1,0x99,0x55,0xfb,0x02,0xba,0x96,0x75,0x58,0x50,0x78,0x71,0x09,0x69,0xd3,0x44,0x0f,0x50,0x54,0xe0},
+    {0xf9,0xdc,0x3e,0x7f,0xe0,0x16,0xe0,0x50,0xef,0xf2,0x60,0x33,0x4f,0x18,0xa5,0xd4,0xfe,0x39,0x1d,0x82,0x09,0x23,0x19,0xf5,0x96,0x4f,0x2e,0x2e,0xb7,0xc1,0xc3,0xa5},
+    {0xf8,0xb1,0x3a,0x49,0xe2,0x82,0xf6,0x09,0xc3,0x17,0xa8,0x33,0xfb,0x8d,0x97,0x6d,0x11,0x51,0x7c,0x57,0x1d,0x12,0x21,0xa2,0x65,0xd2,0x5a,0xf7,0x78,0xec,0xf8,0x92},
+    {0x34,0x90,0xc6,0xce,0xeb,0x45,0x0a,0xec,0xdc,0x82,0xe2,0x82,0x93,0x03,0x1d,0x10,0xc7,0xd7,0x3b,0xf8,0x5e,0x57,0xbf,0x04,0x1a,0x97,0x36,0x0a,0xa2,0xc5,0xd9,0x9c},
+    {0xc1,0xdf,0x82,0xd9,0xc4,0xb8,0x74,0x13,0xea,0xe2,0xef,0x04,0x8f,0x94,0xb4,0xd3,0x55,0x4c,0xea,0x73,0xd9,0x2b,0x0f,0x7a,0xf9,0x6e,0x02,0x71,0xc6,0x91,0xe2,0xbb},
+    {0x5c,0x67,0xad,0xd7,0xc6,0xca,0xf3,0x02,0x25,0x6a,0xde,0xdf,0x7a,0xb1,0x14,0xda,0x0a,0xcf,0xe8,0x70,0xd4,0x49,0xa3,0xa4,0x89,0xf7,0x81,0xd6,0x59,0xe8,0xbe,0xcc},
+    {0xda,0x7b,0xce,0x9f,0x4e,0x86,0x18,0xb6,0xbd,0x2f,0x41,0x32,0xce,0x79,0x8c,0xdc,0x7a,0x60,0xe7,0xe1,0x46,0x0a,0x72,0x99,0xe3,0xc6,0x34,0x2a,0x57,0x96,0x26,0xd2},
+    {0x27,0x33,0xe5,0x0f,0x52,0x6e,0xc2,0xfa,0x19,0xa2,0x2b,0x31,0xe8,0xed,0x50,0xf2,0x3c,0xd1,0xfd,0xf9,0x4c,0x91,0x54,0xed,0x3a,0x76,0x09,0xa2,0xf1,0xff,0x98,0x1f},
+    {0xe1,0xd3,0xb5,0xc8,0x07,0xb2,0x81,0xe4,0x68,0x3c,0xc6,0xd6,0x31,0x5c,0xf9,0x5b,0x9a,0xde,0x86,0x41,0xde,0xfc,0xb3,0x23,0x72,0xf1,0xc1,0x26,0xe3,0x98,0xef,0x7a},
+    {0x5a,0x2d,0xce,0x0a,0x8a,0x7f,0x68,0xbb,0x74,0x56,0x0f,0x8f,0x71,0x83,0x7c,0x2c,0x2e,0xbb,0xcb,0xf7,0xff,0xfb,0x42,0xae,0x18,0x96,0xf1,0x3f,0x7c,0x74,0x79,0xa0},
+    {0xb4,0x6a,0x28,0xb6,0xf5,0x55,0x40,0xf8,0x94,0x44,0xf6,0x3d,0xe0,0x37,0x8e,0x3d,0x12,0x1b,0xe0,0x9e,0x06,0xcc,0x9d,0xed,0x1c,0x20,0xe6,0x58,0x76,0xd3,0x6a,0xa0},
+    {0xc6,0x5e,0x96,0x45,0x64,0x47,0x86,0xb6,0x20,0xe2,0xdd,0x2a,0xd6,0x48,0xdd,0xfc,0xbf,0x4a,0x7e,0x5b,0x1a,0x3a,0x4e,0xcf,0xe7,0xf6,0x46,0x67,0xa3,0xf0,0xb7,0xe2},
+    {0xf4,0x41,0x85,0x88,0xed,0x35,0xa2,0x45,0x8c,0xff,0xeb,0x39,0xb9,0x3d,0x26,0xf1,0x8d,0x2a,0xb1,0x3b,0xdc,0xe6,0xae,0xe5,0x8e,0x7b,0x99,0x35,0x9e,0xc2,0xdf,0xd9},
+    {0x5a,0x9c,0x16,0xdc,0x00,0xd6,0xef,0x18,0xb7,0x93,0x3a,0x6f,0x8d,0xc6,0x5c,0xcb,0x55,0x66,0x71,0x38,0x77,0x6f,0x7d,0xea,0x10,0x10,0x70,0xdc,0x87,0x96,0xe3,0x77},
+    {0x4d,0xf8,0x4f,0x40,0xae,0x0c,0x82,0x29,0xd0,0xd6,0x06,0x9e,0x5c,0x8f,0x39,0xa7,0xc2,0x99,0x67,0x7a,0x09,0xd3,0x67,0xfc,0x7b,0x05,0xe3,0xbc,0x38,0x0e,0xe6,0x52},
+    {0xcd,0xc7,0x25,0x95,0xf7,0x4c,0x7b,0x10,0x43,0xd0,0xe1,0xff,0xba,0xb7,0x34,0x64,0x8c,0x83,0x8d,0xfb,0x05,0x27,0xd9,0x71,0xb6,0x02,0xbc,0x21,0x6c,0x96,0x19,0xef},
+    {0x0a,0xbf,0x5a,0xc9,0x74,0xa1,0xed,0x57,0xf4,0x05,0x0a,0xa5,0x10,0xdd,0x9c,0x74,0xf5,0x08,0x27,0x7b,0x39,0xd7,0x97,0x3b,0xb2,0xdf,0xcc,0xc5,0xee,0xb0,0x61,0x8d},
+    {0xb8,0xcd,0x74,0x04,0x6f,0xf3,0x37,0xf0,0xa7,0xbf,0x2c,0x8e,0x03,0xe1,0x0f,0x64,0x2c,0x18,0x86,0x79,0x8d,0x71,0x80,0x6a,0xb1,0xe8,0x88,0xd9,0xe5,0xee,0x87,0xd0},
+    {0x83,0x8c,0x56,0x55,0xcb,0x21,0xc6,0xcb,0x83,0x31,0x3b,0x5a,0x63,0x11,0x75,0xdf,0xf4,0x96,0x37,0x72,0xcc,0xe9,0x10,0x81,0x88,0xb3,0x4a,0xc8,0x7c,0x81,0xc4,0x1e},
+    {0x66,0x2e,0xe4,0xdd,0x2d,0xd7,0xb2,0xbc,0x70,0x79,0x61,0xb1,0xe6,0x46,0xc4,0x04,0x76,0x69,0xdc,0xb6,0x58,0x4f,0x0d,0x8d,0x77,0x0d,0xaf,0x5d,0x7e,0x7d,0xeb,0x2e},
+    {0x38,0x8a,0xb2,0x0e,0x25,0x73,0xd1,0x71,0xa8,0x81,0x08,0xe7,0x9d,0x82,0x0e,0x98,0xf2,0x6c,0x0b,0x84,0xaa,0x8b,0x2f,0x4a,0xa4,0x96,0x8d,0xbb,0x81,0x8e,0xa3,0x22},
+    {0x93,0x23,0x7c,0x50,0xba,0x75,0xee,0x48,0x5f,0x4c,0x22,0xad,0xf2,0xf7,0x41,0x40,0x0b,0xdf,0x8d,0x6a,0x9c,0xc7,0xdf,0x7e,0xca,0xe5,0x76,0x22,0x16,0x65,0xd7,0x35},
+    {0x84,0x48,0x81,0x8b,0xb4,0xae,0x45,0x62,0x84,0x9e,0x94,0x9e,0x17,0xac,0x16,0xe0,0xbe,0x16,0x68,0x8e,0x15,0x6b,0x5c,0xf1,0x5e,0x09,0x8c,0x62,0x7c,0x00,0x56,0xa9},
+    {0x27,0xae,0x5b,0xa0,0x8d,0x72,0x91,0xc9,0x6c,0x8c,0xbd,0xdc,0xc1,0x48,0xbf,0x48,0xa6,0xd6,0x8c,0x79,0x74,0xb9,0x43,0x56,0xf5,0x37,0x54,0xef,0x61,0x71,0xd7,0x57},
+    {0xbf,0x55,0x8b,0xeb,0xd2,0xce,0xec,0x7f,0x3c,0x5d,0xce,0x04,0xa4,0x78,0x2f,0x88,0xc2,0xc6,0x03,0x6a,0xe7,0x8e,0xe2,0x06,0xd0,0xbc,0x52,0x89,0xd2,0x04,0x61,0xa2},
+    {0xe2,0x19,0x08,0xc2,0x96,0x8c,0x06,0x99,0x04,0x0a,0x6f,0xd8,0x66,0xa5,0x77,0xa9,0x9a,0x9d,0x2e,0xc8,0x87,0x45,0xc8,0x15,0xfd,0x4a,0x47,0x2c,0x78,0x92,0x44,0xda},
+    {0xae,0x82,0x4d,0x72,0xdd,0xc2,0x72,0xaa,0xb6,0x8a,0x8c,0x30,0x22,0xe3,0x6f,0x10,0x45,0x44,0x37,0xc1,0x88,0x6f,0x3f,0xf9,0x92,0x7b,0x64,0xf2,0x32,0xdf,0x41,0x4f},
+    {0x27,0xe4,0x29,0xa4,0xbe,0xf3,0x08,0x3b,0xc3,0x1a,0x67,0x1d,0x04,0x6e,0xa5,0xc1,0xf5,0xb8,0xc3,0x09,0x4d,0x72,0x86,0x8d,0x9d,0xfd,0xc1,0x2c,0x73,0x34,0xac,0x5f},
+    {0x74,0x3c,0xc5,0xc3,0x65,0xa9,0xa6,0xa1,0x5c,0x1f,0x24,0x0a,0xc2,0x58,0x80,0xc7,0xa9,0xd1,0xde,0x29,0x06,0x96,0xcb,0x76,0x60,0x74,0xa1,0xd8,0x3d,0x92,0x78,0x16},
+    {0x4a,0xdc,0xf6,0x16,0xc3,0xbf,0xab,0xf6,0x39,0x99,0xa0,0x19,0x66,0xc9,0x98,0xb7,0xbb,0x57,0x27,0x74,0x03,0x5a,0x63,0xea,0xd4,0x9d,0xa7,0x3b,0x59,0x87,0xf3,0x47},
+    {0x75,0x78,0x66,0x45,0xd0,0xc5,0xdd,0x7c,0x04,0xa2,0xf8,0xa7,0x5d,0xca,0xe0,0x85,0x21,0x36,0x52,0xf5,0xbc,0xe3,0xea,0x8b,0x9b,0x9b,0xed,0xd1,0xca,0xb3,0xc5,0xe9},
+    {0xb8,0x8b,0x15,0x2c,0x9b,0x8a,0x7b,0x79,0x63,0x7d,0x35,0x91,0x18,0x48,0xb0,0xc4,0x1e,0x7c,0xc7,0xcc,0xa2,0xab,0x4f,0xe9,0xa1,0x5f,0x9c,0x38,0xbb,0x4b,0xb9,0x39},
+    {0x0c,0x4e,0x2d,0x8c,0xe8,0x34,0xff,0xd7,0xa6,0xcd,0x85,0xd7,0x11,0x3d,0x45,0x21,0xab,0xb8,0x57,0x77,0x48,0x45,0xc4,0x29,0x1e,0x6f,0x6d,0x01,0x0d,0x97,0xe3,0x18},
+    {0x5b,0xc7,0x99,0xd8,0x3e,0x3b,0xb3,0x15,0x01,0xb3,0xda,0x78,0x66,0x80,0xdf,0x30,0xfb,0xc1,0x8e,0xb4,0x1c,0xbc,0xe6,0x11,0xe8,0xc0,0xe9,0xc7,0x2f,0x69,0x57,0x1c},
+    {0xa1,0x0d,0x3e,0xf8,0x57,0xd0,0x4d,0x9c,0x03,0xea,0xd7,0xc6,0x31,0x7d,0x79,0x7a,0x09,0x0f,0xa1,0x27,0x1a,0xd9,0xc7,0xad,0xdf,0xbc,0xb4,0x12,0xe9,0x64,0x3d,0x4f},
+    {0xb3,0x3b,0x18,0x09,0xc4,0x26,0x23,0xf4,0x74,0x05,0x5f,0xa9,0x40,0x0a,0x20,0x27,0xa7,0xa8,0x85,0xc8,0xdf,0xa4,0xef,0xe2,0x06,0x66,0xb4,0xee,0x27,0xd7,0x52,0x9c},
+    {0x13,0x4d,0x7f,0x28,0xd5,0x3f,0x17,0x5f,0x6b,0xf4,0xb6,0x2f,0xaa,0x21,0x10,0xd5,0xb7,0x6f,0x0f,0x77,0x0c,0x15,0xe6,0x28,0x18,0x1c,0x1f,0xcc,0x18,0xf9,0x70,0xa9},
+    {0xc3,0x4d,0x24,0xb2,0xfc,0x8c,0x50,0xca,0x9c,0x07,0xa7,0x15,0x6e,0xf4,0xe5,0xff,0x4b,0xdf,0x00,0x2e,0xda,0x0b,0x11,0xc1,0xd3,0x59,0xd0,0xb5,0x9a,0x54,0x68,0x07},
+    {0x04,0xdb,0xb9,0xdb,0x63,0x14,0x57,0x87,0x9b,0x27,0xe0,0xdf,0xdb,0xe5,0x01,0x58,0xfd,0x9c,0xf9,0xb4,0xcf,0x77,0x60,0x5c,0x4a,0xc4,0xc9,0x5b,0xd6,0x5f,0xc9,0xf6},
+    {0xf9,0x29,0x5a,0x68,0x66,0x47,0xcb,0x99,0x90,0x90,0x81,0x9c,0xda,0x70,0x08,0x20,0xc2,0x82,0xc6,0x13,0xce,0xdc,0xd2,0x18,0x54,0x0b,0xbc,0x6f,0x37,0xb0,0x1c,0x65},
+    {0x67,0xc4,0xa1,0xea,0x62,0x4f,0x09,0x2a,0x3a,0x5c,0xca,0x2d,0x6f,0x0f,0x0d,0xb2,0x31,0x97,0x2f,0xce,0x62,0x7f,0x0e,0xcc,0xa0,0xde,0xe6,0x0f,0x17,0x55,0x1c,0x5f},
+    {0x8f,0xda,0xeb,0x5a,0xb5,0x60,0xb2,0xce,0xb7,0x81,0xcd,0xb3,0x39,0x36,0x1a,0x0f,0xbe,0xe1,0xb9,0xdf,0xfa,0xd5,0x91,0x15,0x13,0x8c,0x8d,0x6a,0x70,0xdd,0xa9,0xcc},
+    {0xc1,0xbf,0x0b,0xbd,0xd7,0xfe,0xe1,0x57,0x64,0x84,0x5d,0xb8,0x75,0xf6,0x43,0x25,0x59,0xff,0x8d,0xbc,0x90,0x55,0x32,0x44,0x31,0xbc,0x34,0xe5,0xb9,0x3d,0x15,0xda},
+    {0x30,0x73,0x17,0x84,0x9e,0xcc,0xd9,0x0c,0x0c,0x7b,0x98,0x87,0x0b,0x93,0x17,0xc1,0x5a,0x59,0x59,0xdc,0xfb,0x84,0xc7,0x6d,0xcc,0x90,0x8c,0x4f,0xe6,0xba,0x92,0x12},
+    {0x63,0x39,0xbf,0x06,0xe4,0x58,0xf6,0x64,0x6d,0xf5,0xe8,0x3b,0xa7,0xc3,0xd3,0x5b,0xc2,0x63,0xb3,0x22,0x2c,0x8e,0x90,0x40,0x06,0x88,0x47,0x74,0x9c,0xa8,0xe8,0xf9},
+    {0x50,0x45,0xe4,0x34,0x2a,0xeb,0x52,0x1e,0xb3,0xa5,0x58,0x7e,0xc2,0x68,0xed,0x3a,0xa6,0xfa,0xf3,0x2b,0x62,0xb0,0xbc,0x41,0xa9,0xd5,0x49,0x52,0x1f,0x40,0x6f,0xc3},
+    {0x08,0x60,0x1d,0x83,0xcd,0xd3,0x4b,0x5f,0x7b,0x8d,0xf6,0x3e,0x7b,0x9a,0x16,0x51,0x9d,0x35,0x47,0x3d,0x0b,0x89,0xc3,0x17,0xbe,0xed,0x3d,0x3d,0x94,0x24,0xb2,0x53},
+    {0x84,0xe3,0x5c,0x5d,0x92,0x17,0x13,0x76,0xca,0xe5,0xc8,0x63,0x00,0x82,0x2d,0x72,0x9c,0xd3,0xa8,0x47,0x95,0x83,0xbe,0xf0,0x95,0x27,0x02,0x7d,0xba,0x5f,0x11,0x26},
+    {0x3c,0x5c,0xbb,0xeb,0x38,0x34,0xb7,0xa5,0xc1,0xcb,0xa9,0xaa,0x5f,0xee,0x0c,0x95,0xec,0x3f,0x17,0xa3,0x3e,0xc3,0xd8,0x04,0x7f,0xff,0x79,0x91,0x87,0xf5,0xae,0x20},
+    {0x40,0xbb,0xe9,0x13,0xc2,0x26,0xc3,0x4c,0x9f,0xbe,0x43,0x89,0xdd,0x72,0x89,0x84,0x25,0x7a,0x81,0x68,0x92,0xb3,0xca,0xe3,0xe4,0x31,0x91,0xdd,0x29,0x1f,0x0e,0xb5},
+    {0x14,0xaf,0x53,0x85,0xbc,0xbb,0x1e,0x47,0x38,0xbb,0xae,0x81,0x06,0x04,0x6e,0x6e,0x2f,0xca,0x42,0x87,0x5a,0xa5,0xc0,0x00,0xc5,0x82,0x58,0x77,0x42,0xbc,0xc7,0x48},
+    {0x72,0xf2,0x96,0x56,0x80,0x3c,0x2f,0x4b,0xe1,0x77,0xb1,0xb8,0xdd,0x2a,0x51,0x37,0x89,0x2b,0x08,0x0b,0x02,0x21,0x00,0xfd,0xe4,0xe9,0x6d,0x93,0xef,0x8c,0x96,0xff},
+    {0xd0,0x6f,0x27,0x06,0x1c,0x73,0x4d,0x78,0x25,0xb4,0x68,0x65,0xd0,0x0a,0xa9,0x00,0xe5,0xcc,0x3a,0x36,0x72,0x08,0x0e,0x52,0x71,0x71,0xe1,0x17,0x1a,0xa5,0x03,0x8a},
+    {0x28,0x20,0x39,0x85,0xb5,0xf2,0xd8,0x77,0x09,0x17,0x16,0x78,0x16,0x97,0x39,0xf9,0x57,0xd2,0x74,0x5f,0x4b,0xfa,0x5c,0xc9,0x1e,0x2b,0x4b,0xd9,0xbf,0x48,0x3b,0x40},
+    {0x0a,0x16,0x29,0x46,0xe5,0x61,0x58,0xba,0xc0,0x67,0x3e,0x6d,0xd3,0xbd,0xfd,0xc1,0xe4,0xa0,0xe7,0x74,0x4a,0x12,0x0f,0xdb,0x64,0x00,0x50,0xc8,0xd7,0xab,0xe1,0xc6},
+    {0xe2,0xc3,0xed,0x40,0x52,0xee,0xb1,0xd6,0x05,0x14,0xb4,0xc3,0x8e,0xce,0x8d,0x73,0xa2,0x7f,0x37,0xfa,0x5b,0x36,0xdc,0xbf,0x33,0x8e,0x70,0xde,0x95,0x79,0x8c,0xaa}
+};
+// clang-format on
+
+static void copy_hash(const uint8_t src[CMT_KECCAK_LENGTH], uint8_t out[CMT_KECCAK_LENGTH]) {
+    memcpy(out, src, CMT_KECCAK_LENGTH);
+}
+
+static void concat_hash(const uint8_t lhs[CMT_KECCAK_LENGTH], const uint8_t rhs[CMT_KECCAK_LENGTH],
+    uint8_t out[CMT_KECCAK_LENGTH]) {
+    cmt_keccak_t c[1];
+    cmt_keccak_init(c);
+    cmt_keccak_update(c, CMT_KECCAK_LENGTH, lhs);
+    cmt_keccak_update(c, CMT_KECCAK_LENGTH, rhs);
+    cmt_keccak_final(c, out);
+}
+
+#if 0 // NOLINT
+static void print_hash(uint8_t hash[CMT_KECCAK_LENGTH]) {
+    for (int i = 0; i < CMT_KECCAK_LENGTH; ++i) {
+        fprintf(stderr, "%02x", hash[i]);
+    }
+    fprintf(stderr, "\n");
+}
+#endif
+
+void cmt_merkle_init(cmt_merkle_t *me) {
+    cmt_merkle_reset(me);
+}
+
+void cmt_merkle_reset(cmt_merkle_t *me) {
+    me->leaf_count = 0;
+    memset(me->state, 0, sizeof(me->state));
+}
+
+void cmt_merkle_fini(cmt_merkle_t *me) {
+    // no-op
+    (void) me;
+}
+
+int cmt_merkle_load(cmt_merkle_t *me, const char *filepath) {
+    if (!me) {
+        return -EINVAL;
+    }
+    size_t length = 0;
+    int rc = cmt_util_read_whole_file(filepath, sizeof *me, me, &length);
+    if (length != sizeof *me) {
+        return -EINVAL;
+    }
+    return rc;
+}
+
+int cmt_merkle_save(cmt_merkle_t *me, const char *filepath) {
+    if (!me) {
+        return -EINVAL;
+    }
+    return cmt_util_write_whole_file(filepath, sizeof *me, me);
+}
+
+uint64_t cmt_merkle_get_leaf_count(cmt_merkle_t *me) {
+    return me->leaf_count;
+}
+
+int cmt_merkle_push_back(cmt_merkle_t *me, const uint8_t hash[CMT_KECCAK_LENGTH]) {
+    const uint64_t max_count =
+        (CMT_MERKLE_TREE_HEIGHT < 8 * sizeof(uint64_t)) ? (UINT64_C(1) << CMT_MERKLE_TREE_HEIGHT) : UINT64_MAX;
+    if (me->leaf_count == max_count) {
+        return -ENOBUFS;
+    }
+    uint8_t right[CMT_KECCAK_LENGTH];
+    copy_hash(hash, right);
+    for (int i = 0; i < CMT_MERKLE_TREE_HEIGHT; ++i) {
+        uint64_t bit = ((uint64_t) 1) << i;
+        /* if we have a hash for a subtree of the current size in the state... */
+        if (me->leaf_count & bit) {
+            /* ...concat it with current running right and replace running right with it. */
+            concat_hash(me->state[i], right, right);
+            /* otherwise... */
+        } else {
+            /* ...just copy the current subtree hash to the state and we are done. */
+            copy_hash(right, me->state[i]);
+            break;
+        }
+    }
+    ++me->leaf_count;
+    return 0;
+}
+
+void cmt_merkle_get_root_hash(cmt_merkle_t *me, uint8_t root[CMT_KECCAK_LENGTH]) {
+    copy_hash(pristine_hash[0], root);
+    for (int i = 0; i < CMT_MERKLE_TREE_HEIGHT; ++i) {
+        uint64_t bit = ((uint64_t) 1) << i;
+        /* if we have a hash for a subtree of the current size in the state... */
+        if (me->leaf_count & bit) {
+            /* ...concat it with current root on the right and replace root */
+            concat_hash(me->state[i], root, root);
+            /* otherwise... */
+        } else {
+            /* ...concat root with pristine tree on the right and replace root */
+            concat_hash(root, pristine_hash[i], root);
+        }
+    }
+}
+
+int cmt_merkle_push_back_data(cmt_merkle_t *me, size_t length, const void *data) {
+    uint8_t hash[CMT_KECCAK_LENGTH];
+    cmt_keccak_t c[1];
+    cmt_keccak_init(c);
+    cmt_keccak_update(c, length, data);
+    cmt_keccak_final(c, hash);
+    return cmt_merkle_push_back(me, hash);
+}

package/deps/machine-guest-tools/sys-utils/libcmt/src/rollup.c

@@ -0,0 +1,455 @@
+/* Copyright Cartesi and individual authors (see AUTHORS)
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "libcmt/rollup.h"
+#include "libcmt/abi.h"
+#include "libcmt/merkle.h"
+#include "libcmt/util.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+// Voucher(address,uint256,bytes)
+#define VOUCHER CMT_ABI_FUNSEL(0x23, 0x7a, 0x81, 0x6f)
+
+// DelegateCallVoucher(address,bytes)
+#define DELEGATE_CALL_VOUCHER CMT_ABI_FUNSEL(0x10, 0x32, 0x1e, 0x8b)
+
+// Notice(bytes)
+#define NOTICE CMT_ABI_FUNSEL(0xc2, 0x58, 0xd6, 0xe5)
+
+// EvmAdvance(uint256,address,address,uint256,uint256,uint256,uint256,bytes)
+#define EVM_ADVANCE CMT_ABI_FUNSEL(0x41, 0x5b, 0xf3, 0x63)
+
+#define DBG(X) debug(X, #X, __FILE__, __LINE__)
+static int debug(int rc, const char *expr, const char *file, int line) {
+    if (rc == 0) {
+        return 0;
+    }
+
+    if (cmt_util_debug_enabled()) {
+        (void) fprintf(stderr, "%s:%d Error %s on `%s'\n", file, line, expr, strerror(-rc));
+    }
+    return rc;
+}
+
+int cmt_rollup_init(cmt_rollup_t *me) {
+    if (!me) {
+        return -EINVAL;
+    }
+
+    int rc = DBG(cmt_io_init(me->io));
+    if (rc) {
+        return rc;
+    }
+
+    cmt_merkle_init(me->merkle);
+    me->finish_leaf_count = UINT64_C(-1);
+    me->fromhost_data = 0;
+    memset(me->finish_root_hash, 0, sizeof(me->finish_root_hash));
+    return 0;
+}
+
+void cmt_rollup_fini(cmt_rollup_t *me) {
+    if (!me) {
+        return;
+    }
+
+    cmt_io_fini(me->io);
+    cmt_merkle_fini(me->merkle);
+}
+
+int cmt_rollup_emit_voucher(cmt_rollup_t *me, const cmt_abi_address_t *address,
+    const cmt_abi_u256_t *value, const cmt_abi_bytes_t *payload, uint64_t *index) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!payload || (!payload->data && payload->length)) {
+        return -EINVAL;
+    }
+
+    cmt_buf_t tx[1] = {cmt_io_get_tx(me->io)};
+    cmt_buf_t wr[1] = {*tx};
+    cmt_buf_t of[1];
+    cmt_buf_t frame[1];
+
+    // clang-format off
+    if (DBG(cmt_abi_put_funsel(wr, VOUCHER))
+    ||  DBG(cmt_abi_mark_frame(wr, frame))
+    ||  DBG(cmt_abi_put_address(wr, address))
+    ||  DBG(cmt_abi_put_uint256(wr, value))
+    ||  DBG(cmt_abi_put_bytes_s(wr, of))
+    ||  DBG(cmt_abi_put_bytes_d(wr, of, frame, payload))) {
+        return -ENOBUFS;
+    }
+    // clang-format on
+
+    size_t used_space = wr->begin - tx->begin;
+    struct cmt_io_yield req[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_AUTOMATIC,
+        .reason = HTIF_YIELD_AUTOMATIC_REASON_TX_OUTPUT,
+        .data = used_space,
+    }};
+    int rc = DBG(cmt_io_yield(me->io, req));
+    if (rc) {
+        return rc;
+    }
+
+    uint64_t count = cmt_merkle_get_leaf_count(me->merkle);
+
+    rc = cmt_merkle_push_back_data(me->merkle, used_space, tx->begin);
+    if (rc) {
+        return rc;
+    }
+
+    if (index) {
+        *index = count;
+    }
+
+    return 0;
+}
+
+int cmt_rollup_emit_delegate_call_voucher(cmt_rollup_t *me,
+    const cmt_abi_address_t *address, const cmt_abi_bytes_t *payload, uint64_t *index) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!payload || (!payload->data && payload->length)) {
+        return -EINVAL;
+    }
+
+    cmt_buf_t tx[1] = {cmt_io_get_tx(me->io)};
+    cmt_buf_t wr[1] = {*tx};
+    cmt_buf_t of[1];
+    cmt_buf_t frame[1];
+
+    // clang-format off
+    if (DBG(cmt_abi_put_funsel(wr, DELEGATE_CALL_VOUCHER))
+    ||  DBG(cmt_abi_mark_frame(wr, frame))
+    ||  DBG(cmt_abi_put_address(wr, address))
+    ||  DBG(cmt_abi_put_bytes_s(wr, of))
+    ||  DBG(cmt_abi_put_bytes_d(wr, of, frame, payload))) {
+        return -ENOBUFS;
+    }
+    // clang-format on
+
+    size_t used_space = wr->begin - tx->begin;
+    struct cmt_io_yield req[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_AUTOMATIC,
+        .reason = HTIF_YIELD_AUTOMATIC_REASON_TX_OUTPUT,
+        .data = used_space,
+    }};
+    int rc = DBG(cmt_io_yield(me->io, req));
+    if (rc) {
+        return rc;
+    }
+
+    uint64_t count = cmt_merkle_get_leaf_count(me->merkle);
+
+    rc = cmt_merkle_push_back_data(me->merkle, used_space, tx->begin);
+    if (rc) {
+        return rc;
+    }
+
+    if (index) {
+        *index = count;
+    }
+
+    return 0;
+}
+
+int cmt_rollup_emit_notice(cmt_rollup_t *me, const cmt_abi_bytes_t *payload, uint64_t *index) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!payload || (!payload->data && payload->length)) {
+        return -EINVAL;
+    }
+
+    cmt_buf_t tx[1] = {cmt_io_get_tx(me->io)};
+    cmt_buf_t wr[1] = {*tx};
+    cmt_buf_t of[1];
+    cmt_buf_t frame[1];
+
+    // clang-format off
+    if (DBG(cmt_abi_put_funsel(wr, NOTICE))
+    ||  DBG(cmt_abi_mark_frame(wr, frame))
+    ||  DBG(cmt_abi_put_bytes_s(wr, of))
+    ||  DBG(cmt_abi_put_bytes_d(wr, of, frame, payload))) {
+        return -ENOBUFS;
+    }
+    // clang-format on
+
+    size_t used_space = wr->begin - tx->begin;
+    struct cmt_io_yield req[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_AUTOMATIC,
+        .reason = HTIF_YIELD_AUTOMATIC_REASON_TX_OUTPUT,
+        .data = used_space,
+    }};
+    int rc = DBG(cmt_io_yield(me->io, req));
+    if (rc) {
+        return rc;
+    }
+
+    uint64_t count = cmt_merkle_get_leaf_count(me->merkle);
+
+    rc = cmt_merkle_push_back_data(me->merkle, used_space, tx->begin);
+    if (rc) {
+        return rc;
+    }
+
+    if (index) {
+        *index = count;
+    }
+
+    return 0;
+}
+
+int cmt_rollup_emit_report(cmt_rollup_t *me, const cmt_abi_bytes_t *payload) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!payload || (!payload->data && payload->length)) {
+        return -EINVAL;
+    }
+
+    cmt_buf_t tx[1] = {cmt_io_get_tx(me->io)};
+    cmt_buf_t wr[1] = {*tx};
+    if (cmt_buf_split(tx, payload->length, wr, tx)) {
+        return -ENOBUFS;
+    }
+
+    if (payload->data) {
+        memcpy(wr->begin, payload->data, payload->length);
+    }
+    struct cmt_io_yield req[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_AUTOMATIC,
+        .reason = HTIF_YIELD_AUTOMATIC_REASON_TX_REPORT,
+        .data = payload->length,
+    }};
+    return DBG(cmt_io_yield(me->io, req));
+}
+
+int cmt_rollup_emit_exception(cmt_rollup_t *me, const cmt_abi_bytes_t *payload) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!payload || (!payload->data && payload->length)) {
+        return -EINVAL;
+    }
+
+    cmt_buf_t tx[1] = {cmt_io_get_tx(me->io)};
+    cmt_buf_t wr[1] = {*tx};
+    cmt_buf_t _[1];
+    if (cmt_buf_split(tx, payload->length, wr, _)) {
+        return -ENOBUFS;
+    }
+
+    if (payload->data) {
+        memcpy(wr->begin, payload->data, payload->length);
+    }
+    struct cmt_io_yield req[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_MANUAL,
+        .reason = HTIF_YIELD_MANUAL_REASON_TX_EXCEPTION,
+        .data = payload->length,
+    }};
+    return DBG(cmt_io_yield(me->io, req));
+}
+
+static int cmt_rollup_get_rx(cmt_rollup_t *me, cmt_buf_t *lhs) {
+    cmt_buf_t rx[1] = {cmt_io_get_rx(me->io)};
+    cmt_buf_t _[1];
+    return cmt_buf_split(rx, me->fromhost_data, lhs, _);
+}
+
+int cmt_rollup_read_advance_state(cmt_rollup_t *me, cmt_rollup_advance_t *advance) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!advance) {
+        return -EINVAL;
+    }
+
+    cmt_buf_t rd[1];
+    if (cmt_rollup_get_rx(me, rd)) {
+        return -ENOBUFS;
+    }
+    cmt_buf_t frame[1];
+    cmt_buf_t of[1];
+
+    // clang-format off
+    if (DBG(cmt_abi_check_funsel(rd, EVM_ADVANCE))
+    ||  DBG(cmt_abi_mark_frame(rd, frame))
+    ||  DBG(cmt_abi_get_uint(rd, sizeof(advance->chain_id), &advance->chain_id))
+    ||  DBG(cmt_abi_get_address(rd, &advance->app_contract))
+    ||  DBG(cmt_abi_get_address(rd, &advance->msg_sender))
+    ||  DBG(cmt_abi_get_uint(rd, sizeof(advance->block_number), &advance->block_number))
+    ||  DBG(cmt_abi_get_uint(rd, sizeof(advance->block_timestamp), &advance->block_timestamp))
+    ||  DBG(cmt_abi_get_uint256(rd, &advance->prev_randao))
+    ||  DBG(cmt_abi_get_uint(rd, sizeof(advance->index), &advance->index))
+    ||  DBG(cmt_abi_get_bytes_s(rd, of))
+    ||  DBG(cmt_abi_get_bytes_d(frame, of, &advance->payload.length, &advance->payload.data))) {
+        return -ENOBUFS;
+    }
+    // clang-format on
+
+    return 0;
+}
+
+int cmt_rollup_read_inspect_state(cmt_rollup_t *me, cmt_rollup_inspect_t *inspect) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!inspect) {
+        return -EINVAL;
+    }
+
+    cmt_buf_t rd[1];
+    if (DBG(cmt_rollup_get_rx(me, rd))) {
+        return -ENOBUFS;
+    }
+
+    inspect->payload.length = cmt_buf_length(rd);
+    inspect->payload.data = rd->begin;
+    return 0;
+}
+
+static int accepted(union cmt_io_driver *io, uint32_t *n) {
+    struct cmt_io_yield req[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_MANUAL,
+        .reason = HTIF_YIELD_MANUAL_REASON_RX_ACCEPTED,
+        .data = *n,
+    }};
+    int rc = DBG(cmt_io_yield(io, req));
+    if (rc) {
+        return rc;
+    }
+
+    *n = req->data;
+    return req->reason;
+}
+
+static int revert(union cmt_io_driver *io) {
+    struct cmt_io_yield req[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_MANUAL,
+        .reason = HTIF_YIELD_MANUAL_REASON_RX_REJECTED,
+        .data = 0,
+    }};
+    return DBG(cmt_io_yield(io, req));
+}
+
+int cmt_rollup_finish(cmt_rollup_t *me, cmt_rollup_finish_t *finish) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!finish) {
+        return -EINVAL;
+    }
+
+    if (!finish->accept_previous_request) {
+        return revert(me->io); /* revert should not return! */
+    }
+
+    uint64_t leaf_count = cmt_merkle_get_leaf_count(me->merkle);
+    if (me->finish_leaf_count != leaf_count) {
+        cmt_merkle_get_root_hash(me->merkle, me->finish_root_hash);
+    }
+    memcpy(cmt_io_get_tx(me->io).begin, me->finish_root_hash, CMT_ABI_U256_LENGTH);
+    me->fromhost_data = CMT_ABI_U256_LENGTH;
+    int reason = accepted(me->io, &me->fromhost_data);
+    if (reason < 0) {
+        return reason;
+    }
+    finish->next_request_type = reason;
+    finish->next_request_payload_length = me->fromhost_data;
+    me->finish_leaf_count = leaf_count;
+    return 0;
+}
+
+int cmt_gio_request(cmt_rollup_t *me, cmt_gio_t *req) {
+    if (!me) {
+        return -EINVAL;
+    }
+    if (!req) {
+        return -EINVAL;
+    }
+
+    /* Accept empty id */
+    if (!req->id && req->id_length) {
+        return -EINVAL;
+    }
+
+    cmt_buf_t wr[1] = {cmt_io_get_tx(me->io)};
+    cmt_buf_t _[1];
+    if (cmt_buf_split(wr, req->id_length, wr, _)) {
+        return -ENOBUFS;
+    }
+    if (req->id) {
+        memcpy(wr->begin, req->id, req->id_length);
+    }
+
+    struct cmt_io_yield rr[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_MANUAL,
+        .reason = req->domain,
+        .data = req->id_length,
+    }};
+
+    int rc = DBG(cmt_io_yield(me->io, rr));
+    if (rc != 0) {
+        return rc;
+    }
+    me->fromhost_data = rr->data;
+
+    cmt_buf_t rd[1];
+    if (cmt_rollup_get_rx(me, rd)) {
+        return -ENOBUFS;
+    }
+
+    req->response_data = rd->begin;
+    req->response_code = rr->reason;
+    req->response_data_length = rr->data;
+    return 0;
+}
+
+int cmt_rollup_progress(cmt_rollup_t *me, uint32_t progress) {
+    cmt_io_yield_t req[1] = {{
+        .dev = HTIF_DEVICE_YIELD,
+        .cmd = HTIF_YIELD_CMD_AUTOMATIC,
+        .reason = HTIF_YIELD_AUTOMATIC_REASON_PROGRESS,
+        .data = progress,
+    }};
+    return DBG(cmt_io_yield(me->io, req));
+}
+
+int cmt_rollup_load_merkle(cmt_rollup_t *me, const char *path) {
+    return DBG(cmt_merkle_load(me->merkle, path));
+}
+
+int cmt_rollup_save_merkle(cmt_rollup_t *me, const char *path) {
+    return DBG(cmt_merkle_save(me->merkle, path));
+}
+
+void cmt_rollup_reset_merkle(cmt_rollup_t *me) {
+    cmt_merkle_reset(me->merkle);
+}