envio 2.22.0 → 2.22.1

package/src/LogSelection.res.js

@@ -0,0 +1,203 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Utils = require("./Utils.res.js");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+
+var MissingRequiredTopic0 = /* @__PURE__ */Caml_exceptions.create("LogSelection.MissingRequiredTopic0");
+
+function makeTopicSelection(topic0, topic1Opt, topic2Opt, topic3Opt) {
+  var topic1 = topic1Opt !== undefined ? topic1Opt : [];
+  var topic2 = topic2Opt !== undefined ? topic2Opt : [];
+  var topic3 = topic3Opt !== undefined ? topic3Opt : [];
+  if (Utils.$$Array.isEmpty(topic0)) {
+    return {
+            TAG: "Error",
+            _0: {
+              RE_EXN_ID: MissingRequiredTopic0
+            }
+          };
+  } else {
+    return {
+            TAG: "Ok",
+            _0: {
+              topic0: topic0,
+              topic1: topic1,
+              topic2: topic2,
+              topic3: topic3
+            }
+          };
+  }
+}
+
+function hasFilters(param) {
+  return Belt_Option.isSome(Caml_option.undefined_to_opt([
+                    param.topic1,
+                    param.topic2,
+                    param.topic3
+                  ].find(function (topic) {
+                      return !Utils.$$Array.isEmpty(topic);
+                    })));
+}
+
+function compressTopicSelections(topicSelections) {
+  var topic0sOfSelectionsWithoutFilters = [];
+  var selectionsWithFilters = [];
+  Belt_Array.forEach(topicSelections, (function (selection) {
+          if (hasFilters(selection)) {
+            selectionsWithFilters.push(selection);
+            return ;
+          } else {
+            return Belt_Array.forEach(selection.topic0, (function (topic0) {
+                          topic0sOfSelectionsWithoutFilters.push(topic0);
+                        }));
+          }
+        }));
+  if (topic0sOfSelectionsWithoutFilters.length === 0) {
+    return selectionsWithFilters;
+  }
+  var selectionWithoutFilters_topic1 = [];
+  var selectionWithoutFilters_topic2 = [];
+  var selectionWithoutFilters_topic3 = [];
+  var selectionWithoutFilters = {
+    topic0: topic0sOfSelectionsWithoutFilters,
+    topic1: selectionWithoutFilters_topic1,
+    topic2: selectionWithoutFilters_topic2,
+    topic3: selectionWithoutFilters_topic3
+  };
+  return Belt_Array.concat([selectionWithoutFilters], selectionsWithFilters);
+}
+
+function make(addresses, topicSelections) {
+  var topicSelections$1 = compressTopicSelections(topicSelections);
+  return {
+          addresses: addresses,
+          topicSelections: topicSelections$1
+        };
+}
+
+var emptyTopics = [];
+
+function noopGetter(param) {
+  return emptyTopics;
+}
+
+function parseEventFiltersOrThrow(eventFilters, sighash, params, topic1Opt, topic2Opt, topic3Opt) {
+  var topic1 = topic1Opt !== undefined ? topic1Opt : noopGetter;
+  var topic2 = topic2Opt !== undefined ? topic2Opt : noopGetter;
+  var topic3 = topic3Opt !== undefined ? topic3Opt : noopGetter;
+  var filterByAddresses = {
+    contents: false
+  };
+  var topic0 = [sighash];
+  var $$default = {
+    topic0: topic0,
+    topic1: emptyTopics,
+    topic2: emptyTopics,
+    topic3: emptyTopics
+  };
+  var parse = function (eventFilters) {
+    var tmp;
+    tmp = !Array.isArray(eventFilters) && (eventFilters === null || typeof eventFilters !== "object") && typeof eventFilters !== "number" && typeof eventFilters !== "string" && typeof eventFilters !== "boolean" ? [eventFilters] : (
+        Array.isArray(eventFilters) ? (
+            eventFilters.length !== 0 ? eventFilters : [{}]
+          ) : [eventFilters]
+      );
+    return tmp.map(function (eventFilter) {
+                if (!Array.isArray(eventFilter) && (eventFilter === null || typeof eventFilter !== "object") && typeof eventFilter !== "number" && typeof eventFilter !== "string" && typeof eventFilter !== "boolean") {
+                  return Js_exn.raiseError("Invalid event filters configuration. Expected an object");
+                }
+                if (!(typeof eventFilter === "object" && !Array.isArray(eventFilter))) {
+                  return Js_exn.raiseError("Invalid event filters configuration. Expected an object");
+                }
+                var filterKeys = Object.keys(eventFilter);
+                if (filterKeys.length !== 0) {
+                  filterKeys.forEach(function (key) {
+                        if (!params.includes(key)) {
+                          return Js_exn.raiseError("Invalid event filters configuration. The event doesn't have an indexed parameter \"" + key + "\" and can't use it for filtering");
+                        }
+                        
+                      });
+                  return {
+                          topic0: topic0,
+                          topic1: topic1(eventFilter),
+                          topic2: topic2(eventFilter),
+                          topic3: topic3(eventFilter)
+                        };
+                } else {
+                  return $$default;
+                }
+              });
+  };
+  var getEventFiltersOrThrow;
+  if (eventFilters !== undefined) {
+    if (typeof eventFilters === "function") {
+      try {
+        var args = Object.defineProperty({
+              chainId: 0,
+              addresses: []
+            }, "addresses", {
+              get: (function () {
+                  filterByAddresses.contents = true;
+                  return [];
+                })
+            });
+        eventFilters(args);
+      }
+      catch (exn){
+        
+      }
+      getEventFiltersOrThrow = filterByAddresses.contents ? (function (chain) {
+            return {
+                    TAG: "Dynamic",
+                    _0: (function (addresses) {
+                        return parse(eventFilters({
+                                        chainId: chain,
+                                        addresses: addresses
+                                      }));
+                      })
+                  };
+          }) : (function (chain) {
+            return {
+                    TAG: "Static",
+                    _0: parse(eventFilters({
+                              chainId: chain,
+                              addresses: []
+                            }))
+                  };
+          });
+    } else {
+      var $$static = {
+        TAG: "Static",
+        _0: parse(eventFilters)
+      };
+      getEventFiltersOrThrow = (function (param) {
+          return $$static;
+        });
+    }
+  } else {
+    var $$static$1 = {
+      TAG: "Static",
+      _0: [$$default]
+    };
+    getEventFiltersOrThrow = (function (param) {
+        return $$static$1;
+      });
+  }
+  return {
+          getEventFiltersOrThrow: getEventFiltersOrThrow,
+          filterByAddresses: filterByAddresses.contents
+        };
+}
+
+exports.MissingRequiredTopic0 = MissingRequiredTopic0;
+exports.makeTopicSelection = makeTopicSelection;
+exports.hasFilters = hasFilters;
+exports.compressTopicSelections = compressTopicSelections;
+exports.make = make;
+exports.parseEventFiltersOrThrow = parseEventFiltersOrThrow;
+/* Utils Not a pure module */

package/src/Logging.res.js

@@ -0,0 +1,247 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Pino = require("./bindings/Pino.res.js");
+var Pino$1 = require("pino");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var Internal = require("./Internal.res.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var EcsPinoFormat = require("@elastic/ecs-pino-format");
+
+var logLevels = Js_dict.fromArray([
+      [
+        "udebug",
+        32
+      ],
+      [
+        "uinfo",
+        34
+      ],
+      [
+        "uwarn",
+        36
+      ],
+      [
+        "uerror",
+        38
+      ],
+      [
+        "trace",
+        10
+      ],
+      [
+        "debug",
+        20
+      ],
+      [
+        "info",
+        30
+      ],
+      [
+        "warn",
+        40
+      ],
+      [
+        "error",
+        50
+      ],
+      [
+        "fatal",
+        60
+      ]
+    ]);
+
+var logger = {
+  contents: undefined
+};
+
+function makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel) {
+  var pinoFile_target = "pino/file";
+  var pinoFile_options = Caml_option.some(Pino.Transport.makeTransportOptions({
+            destination: logFilePath,
+            append: true,
+            mkdir: true
+          }));
+  var pinoFile_level = defaultFileLogLevel;
+  var pinoFile = {
+    target: pinoFile_target,
+    options: pinoFile_options,
+    level: pinoFile_level
+  };
+  var makeMultiStreamLogger = function (none, none$1) {
+    return Pino.MultiStreamLogger.make(userLogLevel, logLevels, none, none$1, defaultFileLogLevel);
+  };
+  switch (logStrategy) {
+    case "ecs-file" :
+        var newrecord = Caml_obj.obj_dup(EcsPinoFormat());
+        return Pino$1((newrecord.customLevels = logLevels, newrecord), Pino$1.transport(pinoFile));
+    case "ecs-console" :
+        var newrecord$1 = Caml_obj.obj_dup(EcsPinoFormat());
+        return Pino$1((newrecord$1.customLevels = logLevels, newrecord$1.level = userLogLevel, newrecord$1));
+    case "ecs-console-multistream" :
+        return makeMultiStreamLogger(undefined, EcsPinoFormat());
+    case "file-only" :
+        return Pino$1({
+                    level: defaultFileLogLevel,
+                    customLevels: logLevels
+                  }, Pino$1.transport(pinoFile));
+    case "console-raw" :
+    case "console-pretty" :
+        return makeMultiStreamLogger(undefined, undefined);
+    case "both-prettyconsole" :
+        return makeMultiStreamLogger(logFilePath, undefined);
+    
+  }
+}
+
+function setLogger(l) {
+  logger.contents = l;
+}
+
+function getLogger() {
+  var logger$1 = logger.contents;
+  if (logger$1 !== undefined) {
+    return logger$1;
+  } else {
+    return Js_exn.raiseError("Unreachable code. Logger not initialized");
+  }
+}
+
+function setLogLevel(level) {
+  getLogger().level = level;
+}
+
+function trace(message) {
+  getLogger().trace(Pino.createPinoMessage(message));
+}
+
+function debug(message) {
+  getLogger().debug(Pino.createPinoMessage(message));
+}
+
+function info(message) {
+  getLogger().info(Pino.createPinoMessage(message));
+}
+
+function warn(message) {
+  getLogger().warn(Pino.createPinoMessage(message));
+}
+
+function error(message) {
+  getLogger().error(Pino.createPinoMessage(message));
+}
+
+function errorWithExn(error, message) {
+  getLogger().error(Pino.createPinoMessageWithError(message, error));
+}
+
+function fatal(message) {
+  getLogger().fatal(Pino.createPinoMessage(message));
+}
+
+function childTrace(logger, params) {
+  logger.trace(Pino.createPinoMessage(params));
+}
+
+function childDebug(logger, params) {
+  logger.debug(Pino.createPinoMessage(params));
+}
+
+function childInfo(logger, params) {
+  logger.info(Pino.createPinoMessage(params));
+}
+
+function childWarn(logger, params) {
+  logger.warn(Pino.createPinoMessage(params));
+}
+
+function childError(logger, params) {
+  logger.error(Pino.createPinoMessage(params));
+}
+
+function childErrorWithExn(logger, error, params) {
+  logger.error(Pino.createPinoMessageWithError(params, error));
+}
+
+function childFatal(logger, params) {
+  logger.fatal(Pino.createPinoMessage(params));
+}
+
+function createChild(params) {
+  return getLogger().child(Pino.createChildParams(params));
+}
+
+function createChildFrom(logger, params) {
+  return logger.child(Pino.createChildParams(params));
+}
+
+function getEventLogger(eventItem) {
+  var l = eventItem.loggerCache;
+  if (l !== undefined) {
+    return l;
+  }
+  var l$1 = getLogger().child(Pino.createChildParams({
+            contractName: eventItem.eventConfig.contractName,
+            eventName: eventItem.eventConfig.name,
+            chainId: eventItem.chain,
+            block: eventItem.blockNumber,
+            logIndex: eventItem.logIndex
+          }));
+  eventItem.loggerCache = l$1;
+  return l$1;
+}
+
+function logForItem(eventItem, level, message, params) {
+  return getEventLogger(eventItem)[level](params, message);
+}
+
+function getUserLogger(eventItem) {
+  return {
+          debug: (function (message, params) {
+              getEventLogger(eventItem)["udebug"](params, message);
+            }),
+          info: (function (message, params) {
+              getEventLogger(eventItem)["uinfo"](params, message);
+            }),
+          warn: (function (message, params) {
+              getEventLogger(eventItem)["uwarn"](params, message);
+            }),
+          error: (function (message, params) {
+              getEventLogger(eventItem)["uerror"](params, message);
+            }),
+          errorWithExn: (function (message, exn) {
+              var params = {
+                err: Internal.prettifyExn(exn)
+              };
+              getEventLogger(eventItem)["uerror"](params, message);
+            })
+        };
+}
+
+exports.logLevels = logLevels;
+exports.makeLogger = makeLogger;
+exports.setLogger = setLogger;
+exports.getLogger = getLogger;
+exports.setLogLevel = setLogLevel;
+exports.trace = trace;
+exports.debug = debug;
+exports.info = info;
+exports.warn = warn;
+exports.error = error;
+exports.errorWithExn = errorWithExn;
+exports.fatal = fatal;
+exports.childTrace = childTrace;
+exports.childDebug = childDebug;
+exports.childInfo = childInfo;
+exports.childWarn = childWarn;
+exports.childError = childError;
+exports.childErrorWithExn = childErrorWithExn;
+exports.childFatal = childFatal;
+exports.createChild = createChild;
+exports.createChildFrom = createChildFrom;
+exports.getEventLogger = getEventLogger;
+exports.logForItem = logForItem;
+exports.getUserLogger = getUserLogger;
+/* logLevels Not a pure module */

package/src/Persistence.res.js

@@ -0,0 +1,90 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var EntityHistory = require("./db/EntityHistory.res.js");
+var ErrorHandling = require("./ErrorHandling.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var entityHistoryActionEnumConfig_name = EntityHistory.RowAction.name;
+
+var entityHistoryActionEnumConfig_variants = EntityHistory.RowAction.variants;
+
+var entityHistoryActionEnumConfig_schema = EntityHistory.RowAction.schema;
+
+var entityHistoryActionEnumConfig = {
+  name: entityHistoryActionEnumConfig_name,
+  variants: entityHistoryActionEnumConfig_variants,
+  schema: entityHistoryActionEnumConfig_schema,
+  default: "SET"
+};
+
+function make(userEntities, dcRegistryEntityConfig, allEnums, staticTables, storage, onStorageInitialize) {
+  var allEntities = userEntities.concat([dcRegistryEntityConfig]);
+  var allEnums$1 = allEnums.concat([entityHistoryActionEnumConfig]);
+  return {
+          userEntities: userEntities,
+          staticTables: staticTables,
+          allEntities: allEntities,
+          allEnums: allEnums$1,
+          storageStatus: "Unknown",
+          storage: storage,
+          onStorageInitialize: onStorageInitialize
+        };
+}
+
+async function init(persistence, skipIsInitializedCheckOpt, resetOpt) {
+  var skipIsInitializedCheck = skipIsInitializedCheckOpt !== undefined ? skipIsInitializedCheckOpt : false;
+  var reset = resetOpt !== undefined ? resetOpt : false;
+  try {
+    var promise = persistence.storageStatus;
+    var shouldRun;
+    if (typeof promise !== "object") {
+      shouldRun = true;
+    } else if (promise.TAG === "Initializing") {
+      await promise._0;
+      shouldRun = reset;
+    } else {
+      shouldRun = reset;
+    }
+    if (!shouldRun) {
+      return ;
+    }
+    var resolveRef = {
+      contents: null
+    };
+    var promise$1 = new Promise((function (resolve, param) {
+            resolveRef.contents = resolve;
+          }));
+    persistence.storageStatus = {
+      TAG: "Initializing",
+      _0: promise$1
+    };
+    if (!(reset || skipIsInitializedCheck) && await persistence.storage.isInitialized()) {
+      persistence.storageStatus = {
+        TAG: "Ready",
+        cleanRun: false
+      };
+    } else {
+      await persistence.storage.initialize(persistence.allEntities, persistence.staticTables, persistence.allEnums, reset || !skipIsInitializedCheck);
+      persistence.storageStatus = {
+        TAG: "Ready",
+        cleanRun: true
+      };
+      var onStorageInitialize = persistence.onStorageInitialize;
+      if (onStorageInitialize !== undefined) {
+        await onStorageInitialize();
+      }
+      
+    }
+    return resolveRef.contents();
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return ErrorHandling.mkLogAndRaise(undefined, "EE800: Failed to initialize the indexer storage.", exn);
+  }
+}
+
+exports.entityHistoryActionEnumConfig = entityHistoryActionEnumConfig;
+exports.make = make;
+exports.init = init;
+/* EntityHistory Not a pure module */

package/src/PgStorage.res.js

@@ -0,0 +1,125 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var $$Array = require("rescript/lib/js/array.js");
+var Table = require("./db/Table.res.js");
+var Utils = require("./Utils.res.js");
+var Schema = require("./db/Schema.res.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+
+function makeCreateIndexSqlUnsafe(tableName, indexFields, pgSchema) {
+  var indexName = tableName + "_" + indexFields.join("_");
+  var index = Belt_Array.map(indexFields, (function (idx) {
+            return "\"" + idx + "\"";
+          })).join(", ");
+  return "CREATE INDEX IF NOT EXISTS \"" + indexName + "\" ON \"" + pgSchema + "\".\"" + tableName + "\"(" + index + ");";
+}
+
+function makeCreateTableIndicesSqlUnsafe(table, pgSchema) {
+  var tableName = table.tableName;
+  var createIndex = function (indexField) {
+    return makeCreateIndexSqlUnsafe(tableName, [indexField], pgSchema);
+  };
+  var createCompositeIndex = function (indexFields) {
+    return makeCreateIndexSqlUnsafe(tableName, indexFields, pgSchema);
+  };
+  var singleIndices = Table.getSingleIndices(table);
+  var compositeIndices = Table.getCompositeIndices(table);
+  return Belt_Array.map(singleIndices, createIndex).join("\n") + Belt_Array.map(compositeIndices, createCompositeIndex).join("\n");
+}
+
+function makeCreateTableSqlUnsafe(table, pgSchema) {
+  var fieldsMapped = Belt_Array.map(Table.getFields(table), (function (field) {
+            var defaultValue = field.defaultValue;
+            var fieldType = field.fieldType;
+            var fieldName = Table.getDbFieldName(field);
+            var tmp;
+            tmp = fieldType === "TIMESTAMP" || fieldType === "TIMESTAMP WITH TIME ZONE" || fieldType === "JSONB" || fieldType === "SERIAL" || fieldType === "TEXT" || fieldType === "DOUBLE PRECISION" || fieldType === "NUMERIC" || fieldType === "BOOLEAN" || fieldType === "INTEGER" || fieldType === "TIMESTAMP WITH TIME ZONE NULL" || fieldType.startsWith("NUMERIC(") ? fieldType : "\"" + pgSchema + "\"." + fieldType;
+            return "\"" + fieldName + "\" " + tmp + (
+                    field.isArray ? "[]" : ""
+                  ) + (
+                    defaultValue !== undefined ? " DEFAULT " + defaultValue : (
+                        field.isNullable ? "" : " NOT NULL"
+                      )
+                  );
+          })).join(", ");
+  var primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
+  var primaryKey = Belt_Array.map(primaryKeyFieldNames, (function (field) {
+            return "\"" + field + "\"";
+          })).join(", ");
+  return "CREATE TABLE IF NOT EXISTS \"" + pgSchema + "\".\"" + table.tableName + "\"(" + fieldsMapped + (
+          primaryKeyFieldNames.length !== 0 ? ", PRIMARY KEY(" + primaryKey + ")" : ""
+        ) + ");";
+}
+
+function makeInitializeTransaction(pgSchema, staticTables, entities, enums, cleanRun) {
+  var allTables = $$Array.copy(staticTables);
+  var allEntityTables = [];
+  entities.forEach(function (entity) {
+        allEntityTables.push(entity.table);
+        allTables.push(entity.table);
+        allTables.push(entity.entityHistory.table);
+      });
+  var derivedSchema = Schema.make(allEntityTables);
+  var query = {
+    contents: (
+      cleanRun ? "DROP SCHEMA IF EXISTS \"" + pgSchema + "\" CASCADE;\nCREATE SCHEMA \"" + pgSchema + "\";" : "CREATE SCHEMA IF NOT EXISTS \"" + pgSchema + "\";"
+    ) + ("GRANT ALL ON SCHEMA \"" + pgSchema + "\" TO postgres;\nGRANT ALL ON SCHEMA \"" + pgSchema + "\" TO public;")
+  };
+  enums.forEach(function (enumConfig) {
+        var enumCreateQuery = "CREATE TYPE \"" + pgSchema + "\"." + enumConfig.name + " AS ENUM(" + enumConfig.variants.map(function (v) {
+                return "'" + v + "'";
+              }).join(", ") + ");";
+        query.contents = query.contents + "\n" + (
+          cleanRun ? enumCreateQuery : "IF NOT EXISTS (\n  SELECT 1 FROM pg_type \n  WHERE typname = '" + enumConfig.name.toLowerCase() + "' \n  AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = '" + pgSchema + "')\n) THEN \n    " + enumCreateQuery + "\nEND IF;"
+        );
+      });
+  allTables.forEach(function (table) {
+        query.contents = query.contents + "\n" + makeCreateTableSqlUnsafe(table, pgSchema);
+      });
+  allTables.forEach(function (table) {
+        var indices = makeCreateTableIndicesSqlUnsafe(table, pgSchema);
+        if (indices !== "") {
+          query.contents = query.contents + "\n" + indices;
+          return ;
+        }
+        
+      });
+  var functionsQuery = {
+    contents: ""
+  };
+  entities.forEach(function (entity) {
+        functionsQuery.contents = functionsQuery.contents + "\n" + entity.entityHistory.createInsertFnQuery;
+        Table.getDerivedFromFields(entity.table).forEach(function (derivedFromField) {
+              var indexField = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(derivedSchema, derivedFromField));
+              query.contents = query.contents + "\n" + makeCreateIndexSqlUnsafe(derivedFromField.derivedFromEntity, [indexField], pgSchema);
+            });
+      });
+  return [cleanRun ? query.contents : "DO $$ BEGIN " + query.contents + " END $$;"].concat(functionsQuery.contents !== "" ? [functionsQuery.contents] : []);
+}
+
+function make(sql, pgSchema) {
+  var isInitialized = async function () {
+    var schemas = await sql.unsafe("SELECT schema_name FROM information_schema.schemata WHERE schema_name = '" + pgSchema + "';");
+    return Utils.$$Array.notEmpty(schemas);
+  };
+  var initialize = async function (entities, staticTables, enums, cleanRun) {
+    var queries = makeInitializeTransaction(pgSchema, staticTables, entities, enums, cleanRun);
+    await sql.begin(function (sql) {
+          return queries.map(function (query) {
+                      return sql.unsafe(query);
+                    });
+        });
+  };
+  return {
+          isInitialized: isInitialized,
+          initialize: initialize
+        };
+}
+
+exports.makeCreateIndexSqlUnsafe = makeCreateIndexSqlUnsafe;
+exports.makeCreateTableIndicesSqlUnsafe = makeCreateTableIndicesSqlUnsafe;
+exports.makeCreateTableSqlUnsafe = makeCreateTableSqlUnsafe;
+exports.makeInitializeTransaction = makeInitializeTransaction;
+exports.make = make;
+/* Table Not a pure module */