koilib 2.8.0 → 3.1.1

package/lib/utilsNode.js

@@ -0,0 +1,346 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainTypes = exports.decodeGenesisData = exports.encodeGenesisData = void 0;
+const sha256_1 = require("@noble/hashes/sha256");
+const Serializer_1 = require("./Serializer");
+const utils_1 = require("./utils");
+const chain_proto_json_1 = __importDefault(require("./jsonDescriptors/chain-proto.json"));
+const defaultAlias = {
+    "object_key::head_block": { typeName: "block" },
+    "object_key::chain_id": {},
+    "object_key::genesis_key": { isAddress: true },
+    "object_key::resource_limit_data": { typeName: "resource_limit_data" },
+    "object_key::max_account_resources": { typeName: "max_account_resources" },
+    "object_key::protocol_descriptor": {},
+    "object_key::compute_bandwidth_registry": {
+        typeName: "compute_bandwidth_registry",
+    },
+    "object_key::block_hash_code": {},
+};
+function prepareDictionary(dictionary) {
+    const serializerChain = new Serializer_1.Serializer(chain_proto_json_1.default, { bytesConversion: true });
+    const defaultDictionary = {};
+    Object.keys(defaultAlias).forEach((alias) => {
+        const key = (0, utils_1.encodeBase64)((0, utils_1.multihash)((0, sha256_1.sha256)(alias)));
+        defaultDictionary[key] = {
+            serializer: serializerChain,
+            alias,
+            ...defaultAlias[alias],
+        };
+    });
+    const dic = {
+        ...defaultDictionary,
+        ...dictionary,
+    };
+    return dic;
+}
+/**
+ * Function to encode genesis data in order to launch a
+ * new blockchain. The different values are serialized using
+ * protobuffers. One of the arguments is the dictionary which
+ * contains the relevant information to perform the serialization.
+ * By default the function contains the dictionary for the
+ * following keys:
+ *
+ * - "object_key::head_block"
+ * - "object_key::chain_id"
+ * - "object_key::genesis_key"
+ * - "object_key::resource_limit_data"
+ * - "object_key::max_account_resources"
+ * - "object_key::protocol_descriptor"
+ * - "object_key::compute_bandwidth_registry"
+ * - "object_key::block_hash_code"
+ *
+ * @param genesisDataDecoded - Genesis data where the values are
+ * objects.
+ * @param dictionary - Set of keys which contains the relevant
+ * information to perform the serialization
+ *
+ * @example
+ *
+ * ```ts
+ * const signer = Signer.fromSeed("seed");
+ * const genesisDataDecoded = {
+ *   entries: [
+ *     {
+ *       space: { system: true },
+ *       alias: "object_key::genesis_key",
+ *       value: signer.address,
+ *     },
+ *   ],
+ * };
+ *
+ * const genesisData = await encodeGenesisData(genesisDataDecoded);
+ * console.log(genesisData);
+ *
+ * // {
+ * //   entries: [
+ * //     {
+ * //       space: { system: true },
+ * //       key: "EiC3nO+XbeKg4C8ugW7M7XdfmJKY4i3l91KoJWxosQPImA==",
+ * //       value: "AMpASH7CjUHBpl2QR8E5lGKVjVLAvJRg5g==",
+ * //     },
+ * //   ],
+ * // }
+ * ```
+ *
+ * @example adding a custom dictionary
+ *
+ * ```ts
+ * const contractId = Signer.fromSeed("seed").address;
+ * const zone = encodeBase64(decodeBase58(contractId));
+ * const genesisDataDecoded = {
+ *   entries: [
+ *     {
+ *       space: { system: true, zone, id: 1 },
+ *       key: "difficulty_metadata_key",
+ *       value: {
+ *         target: encodeBase64url(toUint8Array("F".repeat(64))),
+ *         last_block_time: "1641038400000",
+ *         difficulty: encodeBase64url(toUint8Array("1".repeat(64))),
+ *         target_block_interval: "10",
+ *       },
+ *     },
+ *   ],
+ * };
+ *
+ * const powJson = {
+ *   nested: {
+ *     mypackage: {
+ *       nested: {
+ *         difficulty_metadata: {
+ *           "fields": {
+ *             "target": { "type": "bytes", "id": 1 },
+ *             "last_block_time": { "type": "uint64", "id": 2,
+ *               "options": { "jstype": "JS_STRING" }
+ *             },
+ *             "difficulty": { "type": "bytes", "id": 3 },
+ *             "target_block_interval": { "type": "uint64", "id": 4,
+ *                "options": { "jstype": "JS_STRING" }
+ *             }
+ *           }
+ *         },
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const dic = {
+ *   difficulty_metadata_key: {
+ *     serializer: new Serializer(powJson),
+ *     typeName: "difficulty_metadata",
+ *   },
+ * };
+ *
+ * const genesisData = await encodeGenesisData(genesisDataDecoded, dic);
+ * console.log(genesisData);
+ *
+ * // {
+ * //   entries: [
+ * //     {
+ * //       key: "difficulty_metadata_key",
+ * //       space: {
+ * //         id: 1,
+ * //         system: true,
+ * //         zone: "AMpASH7CjUHBpl2QR8E5lGKVjVLAvJRg5g==",
+ * //       },
+ * //       value:
+ * //         "CiD//////////////////////////////////////////xCAlIus4S8aIBERERERERERERERERERERERERERERERERERERERERERIAo=",
+ * //     },
+ * //   ],
+ * // };
+ * ```
+ */
+async function encodeGenesisData(genesisDataDecoded, dictionary = {}) {
+    const genesisData = {};
+    if (!genesisDataDecoded || !genesisDataDecoded.entries)
+        return genesisData;
+    const dic = prepareDictionary(dictionary);
+    genesisData.entries = await Promise.all(genesisDataDecoded.entries.map(async (entry) => {
+        const key = Object.keys(dic).find((k) => k === entry.key || (entry.alias && dic[k].alias === entry.alias));
+        if (!key)
+            return {
+                error: `key ${entry.key} not found in the dictionary`,
+                space: entry.space,
+                key: entry.key,
+                value: (0, utils_1.encodeBase64)(new Uint8Array()),
+            };
+        const { isAddress, serializer, typeName } = dic[key];
+        let valueBytes;
+        let error = "";
+        if (isAddress) {
+            valueBytes = (0, utils_1.decodeBase58)(entry.value);
+        }
+        else if (serializer && typeName) {
+            valueBytes = await serializer.serialize(entry.value, typeName);
+        }
+        else {
+            valueBytes = new Uint8Array();
+            error = "no serializer or typeName defined in the dictionary";
+        }
+        return {
+            ...(error && { error }),
+            space: entry.space,
+            key,
+            value: (0, utils_1.encodeBase64)(valueBytes),
+        };
+    }));
+    return genesisData;
+}
+exports.encodeGenesisData = encodeGenesisData;
+/**
+ * Function to decode genesis data used to launch a
+ * new blockchain. The different values are deserialized using
+ * protobuffers. One of the arguments is the dictionary which
+ * contains the relevant information for the deserialization.
+ * By default the function contains the dictionary for the
+ * following keys:
+ *
+ * - "object_key::head_block"
+ * - "object_key::chain_id"
+ * - "object_key::genesis_key"
+ * - "object_key::resource_limit_data"
+ * - "object_key::max_account_resources"
+ * - "object_key::protocol_descriptor"
+ * - "object_key::compute_bandwidth_registry"
+ * - "object_key::block_hash_code"
+ *
+ * @param genesisData - Genesis data
+ * @param dictionary - Set of keys which contains the relevant
+ * information to perform the deserialization
+ *
+ * @example
+ *
+ * ```ts
+ * const genesisData = {
+ *   entries: [
+ *     {
+ *       space: { system: true },
+ *       key: "EiC3nO+XbeKg4C8ugW7M7XdfmJKY4i3l91KoJWxosQPImA==",
+ *       value: "AMpASH7CjUHBpl2QR8E5lGKVjVLAvJRg5g==",
+ *     },
+ *   ],
+ * }
+ *
+ * const genesisDataDecoded = await decodeGenesisData(genesisData);
+ * console.log(genesisDataDecoded);
+ *
+ * // {
+ * //   entries: [
+ * //     {
+ * //       space: { system: true },
+ * //       key: "EiC3nO+XbeKg4C8ugW7M7XdfmJKY4i3l91KoJWxosQPImA==",
+ * //       alias: "object_key::genesis_key",
+ * //       value: "1KSQWDyUnFZ48Pf2hsW8Akh1b5fKUWc8Z3",
+ * //     },
+ * //   ],
+ * // };
+ * ```
+ *
+ * @example adding a custom dictionary
+ *
+ * ```ts
+ * const genesisData = {
+ *   entries: [
+ *     {
+ *       key: "difficulty_metadata_key",
+ *       space: {
+ *         id: 1,
+ *         system: true,
+ *         zone: "AMpASH7CjUHBpl2QR8E5lGKVjVLAvJRg5g==",
+ *       },
+ *       value:
+ *         "CiD//////////////////////////////////////////xCAlIus4S8aIBERERERERERERERERERERERERERERERERERERERERERIAo=",
+ *     },
+ *   ],
+ * };
+ *
+ * const powJson = {
+ *   nested: {
+ *     mypackage: {
+ *       nested: {
+ *         difficulty_metadata: {
+ *           "fields": {
+ *             "target": { "type": "bytes", "id": 1 },
+ *             "last_block_time": { "type": "uint64", "id": 2,
+ *               "options": { "jstype": "JS_STRING" }
+ *             },
+ *             "difficulty": { "type": "bytes", "id": 3 },
+ *             "target_block_interval": { "type": "uint64", "id": 4,
+ *                "options": { "jstype": "JS_STRING" }
+ *             }
+ *           }
+ *         },
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const dic = {
+ *   difficulty_metadata_key: {
+ *     serializer: new Serializer(powJson),
+ *     typeName: "difficulty_metadata",
+ *   },
+ * };
+ *
+ * const genesisDataDecoded = await decodeGenesisData(genesisData, dic);
+ * console.log(genesisData);
+ *
+ * // {
+ * //   entries: [
+ * //     {
+ * //       space: { system: true, zone, id: 1 },
+ * //       key: "difficulty_metadata_key",
+ * //       value: {
+ * //         target: "__________________________________________8=",
+ * //         last_block_time: "1641038400000",
+ * //         difficulty: "ERERERERERERERERERERERERERERERERERERERERERE=",
+ * //         target_block_interval: "10",
+ * //       },
+ * //     },
+ * //   ],
+ * // };
+ * ```
+ */
+async function decodeGenesisData(genesisData, dictionary = {}) {
+    const genesisDataDecoded = {};
+    if (!genesisData || !genesisData.entries)
+        return genesisDataDecoded;
+    const dic = prepareDictionary(dictionary);
+    genesisDataDecoded.entries = await Promise.all(genesisData.entries.map(async (entry) => {
+        const key = Object.keys(dic).find((k) => k === entry.key);
+        if (!key)
+            return {
+                error: `key ${entry.key} not found in the dictionary`,
+                ...entry,
+            };
+        const { isAddress, serializer, typeName, alias } = dic[key];
+        const valueBase64url = (0, utils_1.encodeBase64url)((0, utils_1.decodeBase64)(entry.value));
+        let value;
+        let error = "";
+        if (isAddress) {
+            value = (0, utils_1.encodeBase58)((0, utils_1.decodeBase64url)(valueBase64url));
+        }
+        else if (serializer && typeName) {
+            value = await serializer.deserialize(valueBase64url, typeName);
+        }
+        else {
+            value = valueBase64url;
+            error = "no serializer or typeName defined in the dictionary";
+        }
+        return {
+            ...(error && { error }),
+            space: entry.space,
+            key,
+            value,
+            ...(alias && { alias }),
+        };
+    }));
+    return genesisDataDecoded;
+}
+exports.decodeGenesisData = decodeGenesisData;
+exports.ChainTypes = chain_proto_json_1.default;
+//# sourceMappingURL=utilsNode.js.map

package/lib/utilsNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilsNode.js","sourceRoot":"","sources":["../src/utilsNode.ts"],"names":[],"mappings":";;;;;;AAAA,iDAA8C;AAM9C,6CAA0C;AAC1C,mCAQiB;AACjB,0FAA2D;AAE3D,MAAM,YAAY,GAA0B;IAC1C,wBAAwB,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE;IAC/C,sBAAsB,EAAE,EAAE;IAC1B,yBAAyB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE;IAC9C,iCAAiC,EAAE,EAAE,QAAQ,EAAE,qBAAqB,EAAE;IACtE,mCAAmC,EAAE,EAAE,QAAQ,EAAE,uBAAuB,EAAE;IAC1E,iCAAiC,EAAE,EAAE;IACrC,wCAAwC,EAAE;QACxC,QAAQ,EAAE,4BAA4B;KACvC;IACD,6BAA6B,EAAE,EAAE;CAClC,CAAC;AAEF,SAAS,iBAAiB,CACxB,UAAiC;IAEjC,MAAM,eAAe,GAAG,IAAI,uBAAU,CAAC,0BAAS,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IAE7E,MAAM,iBAAiB,GAA0B,EAAE,CAAC;IACpD,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QAC1C,MAAM,GAAG,GAAG,IAAA,oBAAY,EAAC,IAAA,iBAAS,EAAC,IAAA,eAAM,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACnD,iBAAiB,CAAC,GAAG,CAAC,GAAG;YACvB,UAAU,EAAE,eAAe;YAC3B,KAAK;YACL,GAAG,YAAY,CAAC,KAAK,CAAC;SACvB,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,GAAG,GAAG;QACV,GAAG,iBAAiB;QACpB,GAAG,UAAU;KACd,CAAC;IAEF,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoHG;AACI,KAAK,UAAU,iBAAiB,CACrC,kBAAsC,EACtC,aAAoC,EAAE;IAEtC,MAAM,WAAW,GAAuB,EAAE,CAAC;IAC3C,IAAI,CAAC,kBAAkB,IAAI,CAAC,kBAAkB,CAAC,OAAO;QAAE,OAAO,WAAW,CAAC;IAC3E,MAAM,GAAG,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAE1C,WAAW,CAAC,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CACrC,kBAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QAC7C,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAC/B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,CAAC,CACxE,CAAC;QACF,IAAI,CAAC,GAAG;YACN,OAAO;gBACL,KAAK,EAAE,OAAO,KAAK,CAAC,GAAI,8BAA8B;gBACtD,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,GAAG,EAAE,KAAK,CAAC,GAAG;gBACd,KAAK,EAAE,IAAA,oBAAY,EAAC,IAAI,UAAU,EAAE,CAAC;aACtC,CAAC;QAEJ,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QACrD,IAAI,UAAsB,CAAC;QAC3B,IAAI,KAAK,GAAG,EAAE,CAAC;QACf,IAAI,SAAS,EAAE;YACb,UAAU,GAAG,IAAA,oBAAY,EAAC,KAAK,CAAC,KAAe,CAAC,CAAC;SAClD;aAAM,IAAI,UAAU,IAAI,QAAQ,EAAE;YACjC,UAAU,GAAG,MAAM,UAAU,CAAC,SAAS,CACrC,KAAK,CAAC,KAAgC,EACtC,QAAQ,CACT,CAAC;SACH;aAAM;YACL,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC;YAC9B,KAAK,GAAG,qDAAqD,CAAC;SAC/D;QAED,OAAO;YACL,GAAG,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,CAAC;YACvB,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,GAAG;YACH,KAAK,EAAE,IAAA,oBAAY,EAAC,UAAU,CAAC;SAChC,CAAC;IACJ,CAAC,CAAC,CACH,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC;AA9CD,8CA8CC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHG;AACI,KAAK,UAAU,iBAAiB,CACrC,WAA+B,EAC/B,aAAoC,EAAE;IAEtC,MAAM,kBAAkB,GAAuB,EAAE,CAAC;IAClD,IAAI,CAAC,WAAW,IAAI,CAAC,WAAW,CAAC,OAAO;QAAE,OAAO,kBAAkB,CAAC;IACpE,MAAM,GAAG,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAE1C,kBAAkB,CAAC,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC5C,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QACtC,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1D,IAAI,CAAC,GAAG;YACN,OAAO;gBACL,KAAK,EAAE,OAAO,KAAK,CAAC,GAAI,8BAA8B;gBACtD,GAAG,KAAK;aACT,CAAC;QAEJ,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QAE5D,MAAM,cAAc,GAAG,IAAA,uBAAe,EAAC,IAAA,oBAAY,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAClE,IAAI,KAAuC,CAAC;QAC5C,IAAI,KAAK,GAAG,EAAE,CAAC;QACf,IAAI,SAAS,EAAE;YACb,KAAK,GAAG,IAAA,oBAAY,EAAC,IAAA,uBAAe,EAAC,cAAc,CAAC,CAAC,CAAC;SACvD;aAAM,IAAI,UAAU,IAAI,QAAQ,EAAE;YACjC,KAAK,GAAG,MAAM,UAAU,CAAC,WAAW,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;SAChE;aAAM;YACL,KAAK,GAAG,cAAc,CAAC;YACvB,KAAK,GAAG,qDAAqD,CAAC;SAC/D;QAED,OAAO;YACL,GAAG,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,CAAC;YACvB,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,GAAG;YACH,KAAK;YACL,GAAG,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,CAAC;SACxB,CAAC;IACJ,CAAC,CAAC,CACH,CAAC;IAEF,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AA1CD,8CA0CC;AAEY,QAAA,UAAU,GAAG,0BAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koilib",
-  "version": "2.8.0",
+  "version": "3.1.1",
   "description": "JS Koinos Library",
   "author": "Julian Gonzalez",
   "repository": {

package/lib/browser/jsonDescriptors/protocol-proto.json

@@ -1,246 +0,0 @@
-{
-    "nested": {
-        "koinos": {
-            "nested": {
-                "protocol": {
-                    "options": {
-                        "go_package": "github.com/koinos/koinos-proto-golang/koinos/protocol"
-                    },
-                    "nested": {
-                        "contract_call_bundle": {
-                            "fields": {
-                                "contract_id": {
-                                    "type": "bytes",
-                                    "id": 1,
-                                    "options": {
-                                        "(koinos_bytes_type)": "CONTRACT_ID"
-                                    }
-                                },
-                                "entry_point": {
-                                    "type": "uint32",
-                                    "id": 2
-                                }
-                            }
-                        },
-                        "system_call_target": {
-                            "oneofs": {
-                                "target": {
-                                    "oneof": ["thunk_id", "system_call_bundle"]
-                                }
-                            },
-                            "fields": {
-                                "thunk_id": {
-                                    "type": "uint32",
-                                    "id": 1
-                                },
-                                "system_call_bundle": {
-                                    "type": "contract_call_bundle",
-                                    "id": 2
-                                }
-                            }
-                        },
-                        "upload_contract_operation": {
-                            "fields": {
-                                "contract_id": {
-                                    "type": "bytes",
-                                    "id": 1,
-                                    "options": {
-                                        "(koinos_bytes_type)": "CONTRACT_ID"
-                                    }
-                                },
-                                "bytecode": {
-                                    "type": "bytes",
-                                    "id": 2
-                                }
-                            }
-                        },
-                        "call_contract_operation": {
-                            "fields": {
-                                "contract_id": {
-                                    "type": "bytes",
-                                    "id": 1,
-                                    "options": {
-                                        "(koinos_bytes_type)": "CONTRACT_ID"
-                                    }
-                                },
-                                "entry_point": {
-                                    "type": "uint32",
-                                    "id": 2
-                                },
-                                "args": {
-                                    "type": "bytes",
-                                    "id": 3
-                                }
-                            }
-                        },
-                        "set_system_call_operation": {
-                            "fields": {
-                                "call_id": {
-                                    "type": "uint32",
-                                    "id": 1
-                                },
-                                "target": {
-                                    "type": "system_call_target",
-                                    "id": 2
-                                }
-                            }
-                        },
-                        "operation": {
-                            "oneofs": {
-                                "op": {
-                                    "oneof": [
-                                        "upload_contract",
-                                        "call_contract",
-                                        "set_system_call"
-                                    ]
-                                }
-                            },
-                            "fields": {
-                                "upload_contract": {
-                                    "type": "upload_contract_operation",
-                                    "id": 1
-                                },
-                                "call_contract": {
-                                    "type": "call_contract_operation",
-                                    "id": 2
-                                },
-                                "set_system_call": {
-                                    "type": "set_system_call_operation",
-                                    "id": 3
-                                }
-                            }
-                        },
-                        "active_transaction_data": {
-                            "fields": {
-                                "rc_limit": {
-                                    "type": "uint64",
-                                    "id": 1,
-                                    "options": {
-                                        "jstype": "JS_STRING"
-                                    }
-                                },
-                                "nonce": {
-                                    "type": "uint64",
-                                    "id": 2,
-                                    "options": {
-                                        "jstype": "JS_STRING"
-                                    }
-                                },
-                                "operations": {
-                                    "rule": "repeated",
-                                    "type": "operation",
-                                    "id": 3
-                                }
-                            }
-                        },
-                        "passive_transaction_data": {
-                            "fields": {}
-                        },
-                        "transaction": {
-                            "fields": {
-                                "id": {
-                                    "type": "bytes",
-                                    "id": 1,
-                                    "options": {
-                                        "(koinos_bytes_type)": "TRANSACTION_ID"
-                                    }
-                                },
-                                "active": {
-                                    "type": "bytes",
-                                    "id": 2
-                                },
-                                "passive": {
-                                    "type": "bytes",
-                                    "id": 3
-                                },
-                                "signature_data": {
-                                    "type": "bytes",
-                                    "id": 4
-                                }
-                            }
-                        },
-                        "active_block_data": {
-                            "fields": {
-                                "transaction_merkle_root": {
-                                    "type": "bytes",
-                                    "id": 1
-                                },
-                                "passive_data_merkle_root": {
-                                    "type": "bytes",
-                                    "id": 2
-                                },
-                                "signer": {
-                                    "type": "bytes",
-                                    "id": 3
-                                }
-                            }
-                        },
-                        "passive_block_data": {
-                            "fields": {}
-                        },
-                        "block_header": {
-                            "fields": {
-                                "previous": {
-                                    "type": "bytes",
-                                    "id": 1,
-                                    "options": {
-                                        "(koinos_bytes_type)": "BLOCK_ID"
-                                    }
-                                },
-                                "height": {
-                                    "type": "uint64",
-                                    "id": 2,
-                                    "options": {
-                                        "jstype": "JS_STRING"
-                                    }
-                                },
-                                "timestamp": {
-                                    "type": "uint64",
-                                    "id": 3,
-                                    "options": {
-                                        "jstype": "JS_STRING"
-                                    }
-                                }
-                            }
-                        },
-                        "block": {
-                            "fields": {
-                                "id": {
-                                    "type": "bytes",
-                                    "id": 1,
-                                    "options": {
-                                        "(koinos_bytes_type)": "BLOCK_ID"
-                                    }
-                                },
-                                "header": {
-                                    "type": "block_header",
-                                    "id": 2
-                                },
-                                "active": {
-                                    "type": "bytes",
-                                    "id": 3
-                                },
-                                "passive": {
-                                    "type": "bytes",
-                                    "id": 4
-                                },
-                                "signature_data": {
-                                    "type": "bytes",
-                                    "id": 5
-                                },
-                                "transactions": {
-                                    "rule": "repeated",
-                                    "type": "transaction",
-                                    "id": 6
-                                }
-                            }
-                        },
-                        "block_receipt": {
-                            "fields": {}
-                        }
-                    }
-                }
-            }
-        }
-    }
-}