@latticexyz/cli 2.0.0-alpha.57 → 2.0.0-alpha.58

package/dist/chunk-MTZ2RZBF.js

@@ -0,0 +1,3730 @@
+import {
+  deploy
+} from "./chunk-4UUSCPKW.js";
+import {
+  MUDError,
+  loadStoreConfig,
+  loadWorldConfig,
+  logError
+} from "./chunk-S7JI7355.js";
+import {
+  execLog
+} from "./chunk-FFY7VTYB.js";
+import {
+  anvil,
+  forge,
+  getRpcUrl,
+  getSrcDirectory
+} from "./chunk-FPG73MVN.js";
+import {
+  renderArguments,
+  renderImports,
+  renderList,
+  renderedSolidityHeader,
+  tablegen
+} from "./chunk-MXDV47JM.js";
+import {
+  tsgen
+} from "./chunk-TPZUS44H.js";
+import {
+  formatAndWriteSolidity
+} from "./chunk-5NC2OON2.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-O6HOO6WA.js";
+
+// ../../node_modules/@protobufjs/aspromise/index.js
+var require_aspromise = __commonJS({
+  "../../node_modules/@protobufjs/aspromise/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = asPromise;
+    function asPromise(fn, ctx) {
+      var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
+      while (index < arguments.length)
+        params[offset++] = arguments[index++];
+      return new Promise(function executor(resolve, reject) {
+        params[offset] = function callback(err) {
+          if (pending) {
+            pending = false;
+            if (err)
+              reject(err);
+            else {
+              var params2 = new Array(arguments.length - 1), offset2 = 0;
+              while (offset2 < params2.length)
+                params2[offset2++] = arguments[offset2];
+              resolve.apply(null, params2);
+            }
+          }
+        };
+        try {
+          fn.apply(ctx || null, params);
+        } catch (err) {
+          if (pending) {
+            pending = false;
+            reject(err);
+          }
+        }
+      });
+    }
+  }
+});
+
+// ../../node_modules/@protobufjs/base64/index.js
+var require_base64 = __commonJS({
+  "../../node_modules/@protobufjs/base64/index.js"(exports2) {
+    "use strict";
+    var base64 = exports2;
+    base64.length = function length(string) {
+      var p = string.length;
+      if (!p)
+        return 0;
+      var n = 0;
+      while (--p % 4 > 1 && string.charAt(p) === "=")
+        ++n;
+      return Math.ceil(string.length * 3) / 4 - n;
+    };
+    var b64 = new Array(64);
+    var s64 = new Array(123);
+    for (i = 0; i < 64; )
+      s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+    var i;
+    base64.encode = function encode(buffer, start, end) {
+      var parts = null, chunk = [];
+      var i2 = 0, j = 0, t;
+      while (start < end) {
+        var b = buffer[start++];
+        switch (j) {
+          case 0:
+            chunk[i2++] = b64[b >> 2];
+            t = (b & 3) << 4;
+            j = 1;
+            break;
+          case 1:
+            chunk[i2++] = b64[t | b >> 4];
+            t = (b & 15) << 2;
+            j = 2;
+            break;
+          case 2:
+            chunk[i2++] = b64[t | b >> 6];
+            chunk[i2++] = b64[b & 63];
+            j = 0;
+            break;
+        }
+        if (i2 > 8191) {
+          (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+          i2 = 0;
+        }
+      }
+      if (j) {
+        chunk[i2++] = b64[t];
+        chunk[i2++] = 61;
+        if (j === 1)
+          chunk[i2++] = 61;
+      }
+      if (parts) {
+        if (i2)
+          parts.push(String.fromCharCode.apply(String, chunk.slice(0, i2)));
+        return parts.join("");
+      }
+      return String.fromCharCode.apply(String, chunk.slice(0, i2));
+    };
+    var invalidEncoding = "invalid encoding";
+    base64.decode = function decode(string, buffer, offset) {
+      var start = offset;
+      var j = 0, t;
+      for (var i2 = 0; i2 < string.length; ) {
+        var c = string.charCodeAt(i2++);
+        if (c === 61 && j > 1)
+          break;
+        if ((c = s64[c]) === void 0)
+          throw Error(invalidEncoding);
+        switch (j) {
+          case 0:
+            t = c;
+            j = 1;
+            break;
+          case 1:
+            buffer[offset++] = t << 2 | (c & 48) >> 4;
+            t = c;
+            j = 2;
+            break;
+          case 2:
+            buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+            t = c;
+            j = 3;
+            break;
+          case 3:
+            buffer[offset++] = (t & 3) << 6 | c;
+            j = 0;
+            break;
+        }
+      }
+      if (j === 1)
+        throw Error(invalidEncoding);
+      return offset - start;
+    };
+    base64.test = function test(string) {
+      return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+    };
+  }
+});
+
+// ../../node_modules/@protobufjs/eventemitter/index.js
+var require_eventemitter = __commonJS({
+  "../../node_modules/@protobufjs/eventemitter/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = EventEmitter;
+    function EventEmitter() {
+      this._listeners = {};
+    }
+    EventEmitter.prototype.on = function on(evt, fn, ctx) {
+      (this._listeners[evt] || (this._listeners[evt] = [])).push({
+        fn,
+        ctx: ctx || this
+      });
+      return this;
+    };
+    EventEmitter.prototype.off = function off(evt, fn) {
+      if (evt === void 0)
+        this._listeners = {};
+      else {
+        if (fn === void 0)
+          this._listeners[evt] = [];
+        else {
+          var listeners = this._listeners[evt];
+          for (var i = 0; i < listeners.length; )
+            if (listeners[i].fn === fn)
+              listeners.splice(i, 1);
+            else
+              ++i;
+        }
+      }
+      return this;
+    };
+    EventEmitter.prototype.emit = function emit(evt) {
+      var listeners = this._listeners[evt];
+      if (listeners) {
+        var args = [], i = 1;
+        for (; i < arguments.length; )
+          args.push(arguments[i++]);
+        for (i = 0; i < listeners.length; )
+          listeners[i].fn.apply(listeners[i++].ctx, args);
+      }
+      return this;
+    };
+  }
+});
+
+// ../../node_modules/@protobufjs/float/index.js
+var require_float = __commonJS({
+  "../../node_modules/@protobufjs/float/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = factory(factory);
+    function factory(exports3) {
+      if (typeof Float32Array !== "undefined")
+        (function() {
+          var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128;
+          function writeFloat_f32_cpy(val, buf, pos) {
+            f32[0] = val;
+            buf[pos] = f8b[0];
+            buf[pos + 1] = f8b[1];
+            buf[pos + 2] = f8b[2];
+            buf[pos + 3] = f8b[3];
+          }
+          function writeFloat_f32_rev(val, buf, pos) {
+            f32[0] = val;
+            buf[pos] = f8b[3];
+            buf[pos + 1] = f8b[2];
+            buf[pos + 2] = f8b[1];
+            buf[pos + 3] = f8b[0];
+          }
+          exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+          exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+          function readFloat_f32_cpy(buf, pos) {
+            f8b[0] = buf[pos];
+            f8b[1] = buf[pos + 1];
+            f8b[2] = buf[pos + 2];
+            f8b[3] = buf[pos + 3];
+            return f32[0];
+          }
+          function readFloat_f32_rev(buf, pos) {
+            f8b[3] = buf[pos];
+            f8b[2] = buf[pos + 1];
+            f8b[1] = buf[pos + 2];
+            f8b[0] = buf[pos + 3];
+            return f32[0];
+          }
+          exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+          exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+        })();
+      else
+        (function() {
+          function writeFloat_ieee754(writeUint, val, buf, pos) {
+            var sign = val < 0 ? 1 : 0;
+            if (sign)
+              val = -val;
+            if (val === 0)
+              writeUint(1 / val > 0 ? (
+                /* positive */
+                0
+              ) : (
+                /* negative 0 */
+                2147483648
+              ), buf, pos);
+            else if (isNaN(val))
+              writeUint(2143289344, buf, pos);
+            else if (val > 34028234663852886e22)
+              writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
+            else if (val < 11754943508222875e-54)
+              writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos);
+            else {
+              var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+              writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+            }
+          }
+          exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+          exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+          function readFloat_ieee754(readUint, buf, pos) {
+            var uint = readUint(buf, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
+            return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+          }
+          exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+          exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+        })();
+      if (typeof Float64Array !== "undefined")
+        (function() {
+          var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128;
+          function writeDouble_f64_cpy(val, buf, pos) {
+            f64[0] = val;
+            buf[pos] = f8b[0];
+            buf[pos + 1] = f8b[1];
+            buf[pos + 2] = f8b[2];
+            buf[pos + 3] = f8b[3];
+            buf[pos + 4] = f8b[4];
+            buf[pos + 5] = f8b[5];
+            buf[pos + 6] = f8b[6];
+            buf[pos + 7] = f8b[7];
+          }
+          function writeDouble_f64_rev(val, buf, pos) {
+            f64[0] = val;
+            buf[pos] = f8b[7];
+            buf[pos + 1] = f8b[6];
+            buf[pos + 2] = f8b[5];
+            buf[pos + 3] = f8b[4];
+            buf[pos + 4] = f8b[3];
+            buf[pos + 5] = f8b[2];
+            buf[pos + 6] = f8b[1];
+            buf[pos + 7] = f8b[0];
+          }
+          exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+          exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+          function readDouble_f64_cpy(buf, pos) {
+            f8b[0] = buf[pos];
+            f8b[1] = buf[pos + 1];
+            f8b[2] = buf[pos + 2];
+            f8b[3] = buf[pos + 3];
+            f8b[4] = buf[pos + 4];
+            f8b[5] = buf[pos + 5];
+            f8b[6] = buf[pos + 6];
+            f8b[7] = buf[pos + 7];
+            return f64[0];
+          }
+          function readDouble_f64_rev(buf, pos) {
+            f8b[7] = buf[pos];
+            f8b[6] = buf[pos + 1];
+            f8b[5] = buf[pos + 2];
+            f8b[4] = buf[pos + 3];
+            f8b[3] = buf[pos + 4];
+            f8b[2] = buf[pos + 5];
+            f8b[1] = buf[pos + 6];
+            f8b[0] = buf[pos + 7];
+            return f64[0];
+          }
+          exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+          exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+        })();
+      else
+        (function() {
+          function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+            var sign = val < 0 ? 1 : 0;
+            if (sign)
+              val = -val;
+            if (val === 0) {
+              writeUint(0, buf, pos + off0);
+              writeUint(1 / val > 0 ? (
+                /* positive */
+                0
+              ) : (
+                /* negative 0 */
+                2147483648
+              ), buf, pos + off1);
+            } else if (isNaN(val)) {
+              writeUint(0, buf, pos + off0);
+              writeUint(2146959360, buf, pos + off1);
+            } else if (val > 17976931348623157e292) {
+              writeUint(0, buf, pos + off0);
+              writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+            } else {
+              var mantissa;
+              if (val < 22250738585072014e-324) {
+                mantissa = val / 5e-324;
+                writeUint(mantissa >>> 0, buf, pos + off0);
+                writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+              } else {
+                var exponent = Math.floor(Math.log(val) / Math.LN2);
+                if (exponent === 1024)
+                  exponent = 1023;
+                mantissa = val * Math.pow(2, -exponent);
+                writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+                writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+              }
+            }
+          }
+          exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+          exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+          function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+            var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1);
+            var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo;
+            return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+          }
+          exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+          exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+        })();
+      return exports3;
+    }
+    function writeUintLE(val, buf, pos) {
+      buf[pos] = val & 255;
+      buf[pos + 1] = val >>> 8 & 255;
+      buf[pos + 2] = val >>> 16 & 255;
+      buf[pos + 3] = val >>> 24;
+    }
+    function writeUintBE(val, buf, pos) {
+      buf[pos] = val >>> 24;
+      buf[pos + 1] = val >>> 16 & 255;
+      buf[pos + 2] = val >>> 8 & 255;
+      buf[pos + 3] = val & 255;
+    }
+    function readUintLE(buf, pos) {
+      return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0;
+    }
+    function readUintBE(buf, pos) {
+      return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0;
+    }
+  }
+});
+
+// ../../node_modules/@protobufjs/inquire/index.js
+var require_inquire = __commonJS({
+  "../../node_modules/@protobufjs/inquire/index.js"(exports, module) {
+    "use strict";
+    module.exports = inquire;
+    function inquire(moduleName) {
+      try {
+        var mod = eval("quire".replace(/^/, "re"))(moduleName);
+        if (mod && (mod.length || Object.keys(mod).length))
+          return mod;
+      } catch (e) {
+      }
+      return null;
+    }
+  }
+});
+
+// ../../node_modules/@protobufjs/utf8/index.js
+var require_utf8 = __commonJS({
+  "../../node_modules/@protobufjs/utf8/index.js"(exports2) {
+    "use strict";
+    var utf8 = exports2;
+    utf8.length = function utf8_length(string) {
+      var len = 0, c = 0;
+      for (var i = 0; i < string.length; ++i) {
+        c = string.charCodeAt(i);
+        if (c < 128)
+          len += 1;
+        else if (c < 2048)
+          len += 2;
+        else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) {
+          ++i;
+          len += 4;
+        } else
+          len += 3;
+      }
+      return len;
+    };
+    utf8.read = function utf8_read(buffer, start, end) {
+      var len = end - start;
+      if (len < 1)
+        return "";
+      var parts = null, chunk = [], i = 0, t;
+      while (start < end) {
+        t = buffer[start++];
+        if (t < 128)
+          chunk[i++] = t;
+        else if (t > 191 && t < 224)
+          chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+        else if (t > 239 && t < 365) {
+          t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536;
+          chunk[i++] = 55296 + (t >> 10);
+          chunk[i++] = 56320 + (t & 1023);
+        } else
+          chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+        if (i > 8191) {
+          (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+          i = 0;
+        }
+      }
+      if (parts) {
+        if (i)
+          parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        return parts.join("");
+      }
+      return String.fromCharCode.apply(String, chunk.slice(0, i));
+    };
+    utf8.write = function utf8_write(string, buffer, offset) {
+      var start = offset, c1, c2;
+      for (var i = 0; i < string.length; ++i) {
+        c1 = string.charCodeAt(i);
+        if (c1 < 128) {
+          buffer[offset++] = c1;
+        } else if (c1 < 2048) {
+          buffer[offset++] = c1 >> 6 | 192;
+          buffer[offset++] = c1 & 63 | 128;
+        } else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) {
+          c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+          ++i;
+          buffer[offset++] = c1 >> 18 | 240;
+          buffer[offset++] = c1 >> 12 & 63 | 128;
+          buffer[offset++] = c1 >> 6 & 63 | 128;
+          buffer[offset++] = c1 & 63 | 128;
+        } else {
+          buffer[offset++] = c1 >> 12 | 224;
+          buffer[offset++] = c1 >> 6 & 63 | 128;
+          buffer[offset++] = c1 & 63 | 128;
+        }
+      }
+      return offset - start;
+    };
+  }
+});
+
+// ../../node_modules/@protobufjs/pool/index.js
+var require_pool = __commonJS({
+  "../../node_modules/@protobufjs/pool/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = pool;
+    function pool(alloc, slice, size) {
+      var SIZE = size || 8192;
+      var MAX = SIZE >>> 1;
+      var slab = null;
+      var offset = SIZE;
+      return function pool_alloc(size2) {
+        if (size2 < 1 || size2 > MAX)
+          return alloc(size2);
+        if (offset + size2 > SIZE) {
+          slab = alloc(SIZE);
+          offset = 0;
+        }
+        var buf = slice.call(slab, offset, offset += size2);
+        if (offset & 7)
+          offset = (offset | 7) + 1;
+        return buf;
+      };
+    }
+  }
+});
+
+// ../services/node_modules/protobufjs/src/util/longbits.js
+var require_longbits = __commonJS({
+  "../services/node_modules/protobufjs/src/util/longbits.js"(exports2, module2) {
+    "use strict";
+    module2.exports = LongBits;
+    var util = require_minimal();
+    function LongBits(lo, hi) {
+      this.lo = lo >>> 0;
+      this.hi = hi >>> 0;
+    }
+    var zero = LongBits.zero = new LongBits(0, 0);
+    zero.toNumber = function() {
+      return 0;
+    };
+    zero.zzEncode = zero.zzDecode = function() {
+      return this;
+    };
+    zero.length = function() {
+      return 1;
+    };
+    var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
+    LongBits.fromNumber = function fromNumber2(value) {
+      if (value === 0)
+        return zero;
+      var sign = value < 0;
+      if (sign)
+        value = -value;
+      var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
+      if (sign) {
+        hi = ~hi >>> 0;
+        lo = ~lo >>> 0;
+        if (++lo > 4294967295) {
+          lo = 0;
+          if (++hi > 4294967295)
+            hi = 0;
+        }
+      }
+      return new LongBits(lo, hi);
+    };
+    LongBits.from = function from(value) {
+      if (typeof value === "number")
+        return LongBits.fromNumber(value);
+      if (util.isString(value)) {
+        if (util.Long)
+          value = util.Long.fromString(value);
+        else
+          return LongBits.fromNumber(parseInt(value, 10));
+      }
+      return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+    };
+    LongBits.prototype.toNumber = function toNumber2(unsigned) {
+      if (!unsigned && this.hi >>> 31) {
+        var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0;
+        if (!lo)
+          hi = hi + 1 >>> 0;
+        return -(lo + hi * 4294967296);
+      }
+      return this.lo + this.hi * 4294967296;
+    };
+    LongBits.prototype.toLong = function toLong(unsigned) {
+      return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
+    };
+    var charCodeAt = String.prototype.charCodeAt;
+    LongBits.fromHash = function fromHash(hash) {
+      if (hash === zeroHash)
+        return zero;
+      return new LongBits(
+        (charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0,
+        (charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0
+      );
+    };
+    LongBits.prototype.toHash = function toHash() {
+      return String.fromCharCode(
+        this.lo & 255,
+        this.lo >>> 8 & 255,
+        this.lo >>> 16 & 255,
+        this.lo >>> 24,
+        this.hi & 255,
+        this.hi >>> 8 & 255,
+        this.hi >>> 16 & 255,
+        this.hi >>> 24
+      );
+    };
+    LongBits.prototype.zzEncode = function zzEncode() {
+      var mask = this.hi >> 31;
+      this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+      this.lo = (this.lo << 1 ^ mask) >>> 0;
+      return this;
+    };
+    LongBits.prototype.zzDecode = function zzDecode() {
+      var mask = -(this.lo & 1);
+      this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+      this.hi = (this.hi >>> 1 ^ mask) >>> 0;
+      return this;
+    };
+    LongBits.prototype.length = function length() {
+      var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24;
+      return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
+    };
+  }
+});
+
+// ../services/node_modules/protobufjs/src/util/minimal.js
+var require_minimal = __commonJS({
+  "../services/node_modules/protobufjs/src/util/minimal.js"(exports2) {
+    "use strict";
+    var util = exports2;
+    util.asPromise = require_aspromise();
+    util.base64 = require_base64();
+    util.EventEmitter = require_eventemitter();
+    util.float = require_float();
+    util.inquire = require_inquire();
+    util.utf8 = require_utf8();
+    util.pool = require_pool();
+    util.LongBits = require_longbits();
+    util.isNode = Boolean(typeof global !== "undefined" && global && global.process && global.process.versions && global.process.versions.node);
+    util.global = util.isNode && global || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports2;
+    util.emptyArray = Object.freeze ? Object.freeze([]) : (
+      /* istanbul ignore next */
+      []
+    );
+    util.emptyObject = Object.freeze ? Object.freeze({}) : (
+      /* istanbul ignore next */
+      {}
+    );
+    util.isInteger = Number.isInteger || /* istanbul ignore next */
+    function isInteger(value) {
+      return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+    };
+    util.isString = function isString(value) {
+      return typeof value === "string" || value instanceof String;
+    };
+    util.isObject = function isObject(value) {
+      return value && typeof value === "object";
+    };
+    util.isset = /**
+     * Checks if a property on a message is considered to be present.
+     * @param {Object} obj Plain object or message instance
+     * @param {string} prop Property name
+     * @returns {boolean} `true` if considered to be present, otherwise `false`
+     */
+    util.isSet = function isSet(obj, prop) {
+      var value = obj[prop];
+      if (value != null && obj.hasOwnProperty(prop))
+        return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
+      return false;
+    };
+    util.Buffer = function() {
+      try {
+        var Buffer = util.inquire("buffer").Buffer;
+        return Buffer.prototype.utf8Write ? Buffer : (
+          /* istanbul ignore next */
+          null
+        );
+      } catch (e) {
+        return null;
+      }
+    }();
+    util._Buffer_from = null;
+    util._Buffer_allocUnsafe = null;
+    util.newBuffer = function newBuffer(sizeOrArray) {
+      return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
+    };
+    util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+    util.Long = /* istanbul ignore next */
+    util.global.dcodeIO && /* istanbul ignore next */
+    util.global.dcodeIO.Long || /* istanbul ignore next */
+    util.global.Long || util.inquire("long");
+    util.key2Re = /^true|false|0|1$/;
+    util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
+    util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
+    util.longToHash = function longToHash(value) {
+      return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
+    };
+    util.longFromHash = function longFromHash(hash, unsigned) {
+      var bits = util.LongBits.fromHash(hash);
+      if (util.Long)
+        return util.Long.fromBits(bits.lo, bits.hi, unsigned);
+      return bits.toNumber(Boolean(unsigned));
+    };
+    function merge(dst, src, ifNotSet) {
+      for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
+        if (dst[keys[i]] === void 0 || !ifNotSet)
+          dst[keys[i]] = src[keys[i]];
+      return dst;
+    }
+    util.merge = merge;
+    util.lcFirst = function lcFirst(str) {
+      return str.charAt(0).toLowerCase() + str.substring(1);
+    };
+    function newError(name) {
+      function CustomError(message, properties) {
+        if (!(this instanceof CustomError))
+          return new CustomError(message, properties);
+        Object.defineProperty(this, "message", { get: function() {
+          return message;
+        } });
+        if (Error.captureStackTrace)
+          Error.captureStackTrace(this, CustomError);
+        else
+          Object.defineProperty(this, "stack", { value: new Error().stack || "" });
+        if (properties)
+          merge(this, properties);
+      }
+      CustomError.prototype = Object.create(Error.prototype, {
+        constructor: {
+          value: CustomError,
+          writable: true,
+          enumerable: false,
+          configurable: true
+        },
+        name: {
+          get() {
+            return name;
+          },
+          set: void 0,
+          enumerable: false,
+          // configurable: false would accurately preserve the behavior of
+          // the original, but I'm guessing that was not intentional.
+          // For an actual error subclass, this property would
+          // be configurable.
+          configurable: true
+        },
+        toString: {
+          value() {
+            return this.name + ": " + this.message;
+          },
+          writable: true,
+          enumerable: false,
+          configurable: true
+        }
+      });
+      return CustomError;
+    }
+    util.newError = newError;
+    util.ProtocolError = newError("ProtocolError");
+    util.oneOfGetter = function getOneOf(fieldNames) {
+      var fieldMap = {};
+      for (var i = 0; i < fieldNames.length; ++i)
+        fieldMap[fieldNames[i]] = 1;
+      return function() {
+        for (var keys = Object.keys(this), i2 = keys.length - 1; i2 > -1; --i2)
+          if (fieldMap[keys[i2]] === 1 && this[keys[i2]] !== void 0 && this[keys[i2]] !== null)
+            return keys[i2];
+      };
+    };
+    util.oneOfSetter = function setOneOf(fieldNames) {
+      return function(name) {
+        for (var i = 0; i < fieldNames.length; ++i)
+          if (fieldNames[i] !== name)
+            delete this[fieldNames[i]];
+      };
+    };
+    util.toJSONOptions = {
+      longs: String,
+      enums: String,
+      bytes: String,
+      json: true
+    };
+    util._configure = function() {
+      var Buffer = util.Buffer;
+      if (!Buffer) {
+        util._Buffer_from = util._Buffer_allocUnsafe = null;
+        return;
+      }
+      util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from || /* istanbul ignore next */
+      function Buffer_from(value, encoding) {
+        return new Buffer(value, encoding);
+      };
+      util._Buffer_allocUnsafe = Buffer.allocUnsafe || /* istanbul ignore next */
+      function Buffer_allocUnsafe(size) {
+        return new Buffer(size);
+      };
+    };
+  }
+});
+
+// ../services/node_modules/protobufjs/src/writer.js
+var require_writer = __commonJS({
+  "../services/node_modules/protobufjs/src/writer.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Writer;
+    var util = require_minimal();
+    var BufferWriter;
+    var LongBits = util.LongBits;
+    var base64 = util.base64;
+    var utf8 = util.utf8;
+    function Op(fn, len, val) {
+      this.fn = fn;
+      this.len = len;
+      this.next = void 0;
+      this.val = val;
+    }
+    function noop() {
+    }
+    function State(writer) {
+      this.head = writer.head;
+      this.tail = writer.tail;
+      this.len = writer.len;
+      this.next = writer.states;
+    }
+    function Writer() {
+      this.len = 0;
+      this.head = new Op(noop, 0, 0);
+      this.tail = this.head;
+      this.states = null;
+    }
+    var create = function create2() {
+      return util.Buffer ? function create_buffer_setup() {
+        return (Writer.create = function create_buffer() {
+          return new BufferWriter();
+        })();
+      } : function create_array() {
+        return new Writer();
+      };
+    };
+    Writer.create = create();
+    Writer.alloc = function alloc(size) {
+      return new util.Array(size);
+    };
+    if (util.Array !== Array)
+      Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
+    Writer.prototype._push = function push(fn, len, val) {
+      this.tail = this.tail.next = new Op(fn, len, val);
+      this.len += len;
+      return this;
+    };
+    function writeByte(val, buf, pos) {
+      buf[pos] = val & 255;
+    }
+    function writeVarint32(val, buf, pos) {
+      while (val > 127) {
+        buf[pos++] = val & 127 | 128;
+        val >>>= 7;
+      }
+      buf[pos] = val;
+    }
+    function VarintOp(len, val) {
+      this.len = len;
+      this.next = void 0;
+      this.val = val;
+    }
+    VarintOp.prototype = Object.create(Op.prototype);
+    VarintOp.prototype.fn = writeVarint32;
+    Writer.prototype.uint32 = function write_uint32(value) {
+      this.len += (this.tail = this.tail.next = new VarintOp(
+        (value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5,
+        value
+      )).len;
+      return this;
+    };
+    Writer.prototype.int32 = function write_int32(value) {
+      return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
+    };
+    Writer.prototype.sint32 = function write_sint32(value) {
+      return this.uint32((value << 1 ^ value >> 31) >>> 0);
+    };
+    function writeVarint64(val, buf, pos) {
+      while (val.hi) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
+        val.hi >>>= 7;
+      }
+      while (val.lo > 127) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = val.lo >>> 7;
+      }
+      buf[pos++] = val.lo;
+    }
+    Writer.prototype.uint64 = function write_uint64(value) {
+      var bits = LongBits.from(value);
+      return this._push(writeVarint64, bits.length(), bits);
+    };
+    Writer.prototype.int64 = Writer.prototype.uint64;
+    Writer.prototype.sint64 = function write_sint64(value) {
+      var bits = LongBits.from(value).zzEncode();
+      return this._push(writeVarint64, bits.length(), bits);
+    };
+    Writer.prototype.bool = function write_bool(value) {
+      return this._push(writeByte, 1, value ? 1 : 0);
+    };
+    function writeFixed32(val, buf, pos) {
+      buf[pos] = val & 255;
+      buf[pos + 1] = val >>> 8 & 255;
+      buf[pos + 2] = val >>> 16 & 255;
+      buf[pos + 3] = val >>> 24;
+    }
+    Writer.prototype.fixed32 = function write_fixed32(value) {
+      return this._push(writeFixed32, 4, value >>> 0);
+    };
+    Writer.prototype.sfixed32 = Writer.prototype.fixed32;
+    Writer.prototype.fixed64 = function write_fixed64(value) {
+      var bits = LongBits.from(value);
+      return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+    };
+    Writer.prototype.sfixed64 = Writer.prototype.fixed64;
+    Writer.prototype.float = function write_float(value) {
+      return this._push(util.float.writeFloatLE, 4, value);
+    };
+    Writer.prototype.double = function write_double(value) {
+      return this._push(util.float.writeDoubleLE, 8, value);
+    };
+    var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) {
+      buf.set(val, pos);
+    } : function writeBytes_for(val, buf, pos) {
+      for (var i = 0; i < val.length; ++i)
+        buf[pos + i] = val[i];
+    };
+    Writer.prototype.bytes = function write_bytes(value) {
+      var len = value.length >>> 0;
+      if (!len)
+        return this._push(writeByte, 1, 0);
+      if (util.isString(value)) {
+        var buf = Writer.alloc(len = base64.length(value));
+        base64.decode(value, buf, 0);
+        value = buf;
+      }
+      return this.uint32(len)._push(writeBytes, len, value);
+    };
+    Writer.prototype.string = function write_string(value) {
+      var len = utf8.length(value);
+      return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0);
+    };
+    Writer.prototype.fork = function fork() {
+      this.states = new State(this);
+      this.head = this.tail = new Op(noop, 0, 0);
+      this.len = 0;
+      return this;
+    };
+    Writer.prototype.reset = function reset() {
+      if (this.states) {
+        this.head = this.states.head;
+        this.tail = this.states.tail;
+        this.len = this.states.len;
+        this.states = this.states.next;
+      } else {
+        this.head = this.tail = new Op(noop, 0, 0);
+        this.len = 0;
+      }
+      return this;
+    };
+    Writer.prototype.ldelim = function ldelim() {
+      var head = this.head, tail = this.tail, len = this.len;
+      this.reset().uint32(len);
+      if (len) {
+        this.tail.next = head.next;
+        this.tail = tail;
+        this.len += len;
+      }
+      return this;
+    };
+    Writer.prototype.finish = function finish() {
+      var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0;
+      while (head) {
+        head.fn(head.val, buf, pos);
+        pos += head.len;
+        head = head.next;
+      }
+      return buf;
+    };
+    Writer._configure = function(BufferWriter_) {
+      BufferWriter = BufferWriter_;
+      Writer.create = create();
+      BufferWriter._configure();
+    };
+  }
+});
+
+// ../services/node_modules/protobufjs/src/writer_buffer.js
+var require_writer_buffer = __commonJS({
+  "../services/node_modules/protobufjs/src/writer_buffer.js"(exports2, module2) {
+    "use strict";
+    module2.exports = BufferWriter;
+    var Writer = require_writer();
+    (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
+    var util = require_minimal();
+    function BufferWriter() {
+      Writer.call(this);
+    }
+    BufferWriter._configure = function() {
+      BufferWriter.alloc = util._Buffer_allocUnsafe;
+      BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
+        buf.set(val, pos);
+      } : function writeBytesBuffer_copy(val, buf, pos) {
+        if (val.copy)
+          val.copy(buf, pos, 0, val.length);
+        else
+          for (var i = 0; i < val.length; )
+            buf[pos++] = val[i++];
+      };
+    };
+    BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
+      if (util.isString(value))
+        value = util._Buffer_from(value, "base64");
+      var len = value.length >>> 0;
+      this.uint32(len);
+      if (len)
+        this._push(BufferWriter.writeBytesBuffer, len, value);
+      return this;
+    };
+    function writeStringBuffer(val, buf, pos) {
+      if (val.length < 40)
+        util.utf8.write(val, buf, pos);
+      else if (buf.utf8Write)
+        buf.utf8Write(val, pos);
+      else
+        buf.write(val, pos);
+    }
+    BufferWriter.prototype.string = function write_string_buffer(value) {
+      var len = util.Buffer.byteLength(value);
+      this.uint32(len);
+      if (len)
+        this._push(writeStringBuffer, len, value);
+      return this;
+    };
+    BufferWriter._configure();
+  }
+});
+
+// ../services/node_modules/protobufjs/src/reader.js
+var require_reader = __commonJS({
+  "../services/node_modules/protobufjs/src/reader.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Reader;
+    var util = require_minimal();
+    var BufferReader;
+    var LongBits = util.LongBits;
+    var utf8 = util.utf8;
+    function indexOutOfRange(reader, writeLength) {
+      return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+    }
+    function Reader(buffer) {
+      this.buf = buffer;
+      this.pos = 0;
+      this.len = buffer.length;
+    }
+    var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
+      if (buffer instanceof Uint8Array || Array.isArray(buffer))
+        return new Reader(buffer);
+      throw Error("illegal buffer");
+    } : function create_array2(buffer) {
+      if (Array.isArray(buffer))
+        return new Reader(buffer);
+      throw Error("illegal buffer");
+    };
+    var create = function create2() {
+      return util.Buffer ? function create_buffer_setup(buffer) {
+        return (Reader.create = function create_buffer(buffer2) {
+          return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
+        })(buffer);
+      } : create_array;
+    };
+    Reader.create = create();
+    Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */
+    util.Array.prototype.slice;
+    Reader.prototype.uint32 = function read_uint32_setup() {
+      var value = 4294967295;
+      return function read_uint32() {
+        value = (this.buf[this.pos] & 127) >>> 0;
+        if (this.buf[this.pos++] < 128)
+          return value;
+        value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
+        if (this.buf[this.pos++] < 128)
+          return value;
+        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
+        if (this.buf[this.pos++] < 128)
+          return value;
+        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
+        if (this.buf[this.pos++] < 128)
+          return value;
+        value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
+        if (this.buf[this.pos++] < 128)
+          return value;
+        if ((this.pos += 5) > this.len) {
+          this.pos = this.len;
+          throw indexOutOfRange(this, 10);
+        }
+        return value;
+      };
+    }();
+    Reader.prototype.int32 = function read_int32() {
+      return this.uint32() | 0;
+    };
+    Reader.prototype.sint32 = function read_sint32() {
+      var value = this.uint32();
+      return value >>> 1 ^ -(value & 1) | 0;
+    };
+    function readLongVarint() {
+      var bits = new LongBits(0, 0);
+      var i = 0;
+      if (this.len - this.pos > 4) {
+        for (; i < 4; ++i) {
+          bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+          if (this.buf[this.pos++] < 128)
+            return bits;
+        }
+        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
+        if (this.buf[this.pos++] < 128)
+          return bits;
+        i = 0;
+      } else {
+        for (; i < 3; ++i) {
+          if (this.pos >= this.len)
+            throw indexOutOfRange(this);
+          bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+          if (this.buf[this.pos++] < 128)
+            return bits;
+        }
+        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+        return bits;
+      }
+      if (this.len - this.pos > 4) {
+        for (; i < 5; ++i) {
+          bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+          if (this.buf[this.pos++] < 128)
+            return bits;
+        }
+      } else {
+        for (; i < 5; ++i) {
+          if (this.pos >= this.len)
+            throw indexOutOfRange(this);
+          bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+          if (this.buf[this.pos++] < 128)
+            return bits;
+        }
+      }
+      throw Error("invalid varint encoding");
+    }
+    Reader.prototype.bool = function read_bool() {
+      return this.uint32() !== 0;
+    };
+    function readFixed32_end(buf, end) {
+      return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
+    }
+    Reader.prototype.fixed32 = function read_fixed32() {
+      if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+      return readFixed32_end(this.buf, this.pos += 4);
+    };
+    Reader.prototype.sfixed32 = function read_sfixed32() {
+      if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+      return readFixed32_end(this.buf, this.pos += 4) | 0;
+    };
+    function readFixed64() {
+      if (this.pos + 8 > this.len)
+        throw indexOutOfRange(this, 8);
+      return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
+    }
+    Reader.prototype.float = function read_float() {
+      if (this.pos + 4 > this.len)
+        throw indexOutOfRange(this, 4);
+      var value = util.float.readFloatLE(this.buf, this.pos);
+      this.pos += 4;
+      return value;
+    };
+    Reader.prototype.double = function read_double() {
+      if (this.pos + 8 > this.len)
+        throw indexOutOfRange(this, 4);
+      var value = util.float.readDoubleLE(this.buf, this.pos);
+      this.pos += 8;
+      return value;
+    };
+    Reader.prototype.bytes = function read_bytes() {
+      var length = this.uint32(), start = this.pos, end = this.pos + length;
+      if (end > this.len)
+        throw indexOutOfRange(this, length);
+      this.pos += length;
+      if (Array.isArray(this.buf))
+        return this.buf.slice(start, end);
+      return start === end ? new this.buf.constructor(0) : this._slice.call(this.buf, start, end);
+    };
+    Reader.prototype.string = function read_string() {
+      var bytes = this.bytes();
+      return utf8.read(bytes, 0, bytes.length);
+    };
+    Reader.prototype.skip = function skip(length) {
+      if (typeof length === "number") {
+        if (this.pos + length > this.len)
+          throw indexOutOfRange(this, length);
+        this.pos += length;
+      } else {
+        do {
+          if (this.pos >= this.len)
+            throw indexOutOfRange(this);
+        } while (this.buf[this.pos++] & 128);
+      }
+      return this;
+    };
+    Reader.prototype.skipType = function(wireType) {
+      switch (wireType) {
+        case 0:
+          this.skip();
+          break;
+        case 1:
+          this.skip(8);
+          break;
+        case 2:
+          this.skip(this.uint32());
+          break;
+        case 3:
+          while ((wireType = this.uint32() & 7) !== 4) {
+            this.skipType(wireType);
+          }
+          break;
+        case 5:
+          this.skip(4);
+          break;
+        default:
+          throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+      }
+      return this;
+    };
+    Reader._configure = function(BufferReader_) {
+      BufferReader = BufferReader_;
+      Reader.create = create();
+      BufferReader._configure();
+      var fn = util.Long ? "toLong" : (
+        /* istanbul ignore next */
+        "toNumber"
+      );
+      util.merge(Reader.prototype, {
+        int64: function read_int64() {
+          return readLongVarint.call(this)[fn](false);
+        },
+        uint64: function read_uint64() {
+          return readLongVarint.call(this)[fn](true);
+        },
+        sint64: function read_sint64() {
+          return readLongVarint.call(this).zzDecode()[fn](false);
+        },
+        fixed64: function read_fixed64() {
+          return readFixed64.call(this)[fn](true);
+        },
+        sfixed64: function read_sfixed64() {
+          return readFixed64.call(this)[fn](false);
+        }
+      });
+    };
+  }
+});
+
+// ../services/node_modules/protobufjs/src/reader_buffer.js
+var require_reader_buffer = __commonJS({
+  "../services/node_modules/protobufjs/src/reader_buffer.js"(exports2, module2) {
+    "use strict";
+    module2.exports = BufferReader;
+    var Reader = require_reader();
+    (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
+    var util = require_minimal();
+    function BufferReader(buffer) {
+      Reader.call(this, buffer);
+    }
+    BufferReader._configure = function() {
+      if (util.Buffer)
+        BufferReader.prototype._slice = util.Buffer.prototype.slice;
+    };
+    BufferReader.prototype.string = function read_string_buffer() {
+      var len = this.uint32();
+      return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
+    };
+    BufferReader._configure();
+  }
+});
+
+// ../services/node_modules/protobufjs/src/rpc/service.js
+var require_service = __commonJS({
+  "../services/node_modules/protobufjs/src/rpc/service.js"(exports2, module2) {
+    "use strict";
+    module2.exports = Service;
+    var util = require_minimal();
+    (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
+    function Service(rpcImpl, requestDelimited, responseDelimited) {
+      if (typeof rpcImpl !== "function")
+        throw TypeError("rpcImpl must be a function");
+      util.EventEmitter.call(this);
+      this.rpcImpl = rpcImpl;
+      this.requestDelimited = Boolean(requestDelimited);
+      this.responseDelimited = Boolean(responseDelimited);
+    }
+    Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
+      if (!request)
+        throw TypeError("request must be specified");
+      var self2 = this;
+      if (!callback)
+        return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request);
+      if (!self2.rpcImpl) {
+        setTimeout(function() {
+          callback(Error("already ended"));
+        }, 0);
+        return void 0;
+      }
+      try {
+        return self2.rpcImpl(
+          method,
+          requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
+          function rpcCallback(err, response) {
+            if (err) {
+              self2.emit("error", err, method);
+              return callback(err);
+            }
+            if (response === null) {
+              self2.end(
+                /* endedByRPC */
+                true
+              );
+              return void 0;
+            }
+            if (!(response instanceof responseCtor)) {
+              try {
+                response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response);
+              } catch (err2) {
+                self2.emit("error", err2, method);
+                return callback(err2);
+              }
+            }
+            self2.emit("data", response, method);
+            return callback(null, response);
+          }
+        );
+      } catch (err) {
+        self2.emit("error", err, method);
+        setTimeout(function() {
+          callback(err);
+        }, 0);
+        return void 0;
+      }
+    };
+    Service.prototype.end = function end(endedByRPC) {
+      if (this.rpcImpl) {
+        if (!endedByRPC)
+          this.rpcImpl(null, null, null);
+        this.rpcImpl = null;
+        this.emit("end").off();
+      }
+      return this;
+    };
+  }
+});
+
+// ../services/node_modules/protobufjs/src/rpc.js
+var require_rpc = __commonJS({
+  "../services/node_modules/protobufjs/src/rpc.js"(exports2) {
+    "use strict";
+    var rpc = exports2;
+    rpc.Service = require_service();
+  }
+});
+
+// ../services/node_modules/protobufjs/src/roots.js
+var require_roots = __commonJS({
+  "../services/node_modules/protobufjs/src/roots.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {};
+  }
+});
+
+// ../services/node_modules/protobufjs/src/index-minimal.js
+var require_index_minimal = __commonJS({
+  "../services/node_modules/protobufjs/src/index-minimal.js"(exports2) {
+    "use strict";
+    var protobuf = exports2;
+    protobuf.build = "minimal";
+    protobuf.Writer = require_writer();
+    protobuf.BufferWriter = require_writer_buffer();
+    protobuf.Reader = require_reader();
+    protobuf.BufferReader = require_reader_buffer();
+    protobuf.util = require_minimal();
+    protobuf.rpc = require_rpc();
+    protobuf.roots = require_roots();
+    protobuf.configure = configure;
+    function configure() {
+      protobuf.util._configure();
+      protobuf.Writer._configure(protobuf.BufferWriter);
+      protobuf.Reader._configure(protobuf.BufferReader);
+    }
+    configure();
+  }
+});
+
+// ../services/node_modules/protobufjs/minimal.js
+var require_minimal2 = __commonJS({
+  "../services/node_modules/protobufjs/minimal.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_index_minimal();
+  }
+});
+
+// src/commands/devnode.ts
+import { rmSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+var commandModule = {
+  command: "devnode",
+  describe: "Start a local Ethereum node for development",
+  builder(yargs) {
+    return yargs.options({
+      blocktime: { type: "number", default: 1, decs: "Interval in which new blocks are produced" }
+    });
+  },
+  async handler({ blocktime }) {
+    console.log("Clearing devnode history");
+    const userHomeDir = homedir();
+    rmSync(path.join(userHomeDir, ".foundry", "anvil", "tmp"), { recursive: true, force: true });
+    const child = execLog("anvil", ["-b", String(blocktime), "--block-base-fee-per-gas", "0"]);
+    process.on("SIGINT", () => {
+      console.log("\ngracefully shutting down from SIGINT (Crtl-C)");
+      child.kill();
+      process.exit();
+    });
+    await child;
+  }
+};
+var devnode_default = commandModule;
+
+// ../services/node_modules/long/index.js
+var wasm = null;
+try {
+  wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
+    0,
+    97,
+    115,
+    109,
+    1,
+    0,
+    0,
+    0,
+    1,
+    13,
+    2,
+    96,
+    0,
+    1,
+    127,
+    96,
+    4,
+    127,
+    127,
+    127,
+    127,
+    1,
+    127,
+    3,
+    7,
+    6,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    6,
+    6,
+    1,
+    127,
+    1,
+    65,
+    0,
+    11,
+    7,
+    50,
+    6,
+    3,
+    109,
+    117,
+    108,
+    0,
+    1,
+    5,
+    100,
+    105,
+    118,
+    95,
+    115,
+    0,
+    2,
+    5,
+    100,
+    105,
+    118,
+    95,
+    117,
+    0,
+    3,
+    5,
+    114,
+    101,
+    109,
+    95,
+    115,
+    0,
+    4,
+    5,
+    114,
+    101,
+    109,
+    95,
+    117,
+    0,
+    5,
+    8,
+    103,
+    101,
+    116,
+    95,
+    104,
+    105,
+    103,
+    104,
+    0,
+    0,
+    10,
+    191,
+    1,
+    6,
+    4,
+    0,
+    35,
+    0,
+    11,
+    36,
+    1,
+    1,
+    126,
+    32,
+    0,
+    173,
+    32,
+    1,
+    173,
+    66,
+    32,
+    134,
+    132,
+    32,
+    2,
+    173,
+    32,
+    3,
+    173,
+    66,
+    32,
+    134,
+    132,
+    126,
+    34,
+    4,
+    66,
+    32,
+    135,
+    167,
+    36,
+    0,
+    32,
+    4,
+    167,
+    11,
+    36,
+    1,
+    1,
+    126,
+    32,
+    0,
+    173,
+    32,
+    1,
+    173,
+    66,
+    32,
+    134,
+    132,
+    32,
+    2,
+    173,
+    32,
+    3,
+    173,
+    66,
+    32,
+    134,
+    132,
+    127,
+    34,
+    4,
+    66,
+    32,
+    135,
+    167,
+    36,
+    0,
+    32,
+    4,
+    167,
+    11,
+    36,
+    1,
+    1,
+    126,
+    32,
+    0,
+    173,
+    32,
+    1,
+    173,
+    66,
+    32,
+    134,
+    132,
+    32,
+    2,
+    173,
+    32,
+    3,
+    173,
+    66,
+    32,
+    134,
+    132,
+    128,
+    34,
+    4,
+    66,
+    32,
+    135,
+    167,
+    36,
+    0,
+    32,
+    4,
+    167,
+    11,
+    36,
+    1,
+    1,
+    126,
+    32,
+    0,
+    173,
+    32,
+    1,
+    173,
+    66,
+    32,
+    134,
+    132,
+    32,
+    2,
+    173,
+    32,
+    3,
+    173,
+    66,
+    32,
+    134,
+    132,
+    129,
+    34,
+    4,
+    66,
+    32,
+    135,
+    167,
+    36,
+    0,
+    32,
+    4,
+    167,
+    11,
+    36,
+    1,
+    1,
+    126,
+    32,
+    0,
+    173,
+    32,
+    1,
+    173,
+    66,
+    32,
+    134,
+    132,
+    32,
+    2,
+    173,
+    32,
+    3,
+    173,
+    66,
+    32,
+    134,
+    132,
+    130,
+    34,
+    4,
+    66,
+    32,
+    135,
+    167,
+    36,
+    0,
+    32,
+    4,
+    167,
+    11
+  ])), {}).exports;
+} catch (e) {
+}
+function Long(low, high, unsigned) {
+  this.low = low | 0;
+  this.high = high | 0;
+  this.unsigned = !!unsigned;
+}
+Long.prototype.__isLong__;
+Object.defineProperty(Long.prototype, "__isLong__", { value: true });
+function isLong(obj) {
+  return (obj && obj["__isLong__"]) === true;
+}
+function ctz32(value) {
+  var c = Math.clz32(value & -value);
+  return value ? 31 - c : c;
+}
+Long.isLong = isLong;
+var INT_CACHE = {};
+var UINT_CACHE = {};
+function fromInt(value, unsigned) {
+  var obj, cachedObj, cache;
+  if (unsigned) {
+    value >>>= 0;
+    if (cache = 0 <= value && value < 256) {
+      cachedObj = UINT_CACHE[value];
+      if (cachedObj)
+        return cachedObj;
+    }
+    obj = fromBits(value, 0, true);
+    if (cache)
+      UINT_CACHE[value] = obj;
+    return obj;
+  } else {
+    value |= 0;
+    if (cache = -128 <= value && value < 128) {
+      cachedObj = INT_CACHE[value];
+      if (cachedObj)
+        return cachedObj;
+    }
+    obj = fromBits(value, value < 0 ? -1 : 0, false);
+    if (cache)
+      INT_CACHE[value] = obj;
+    return obj;
+  }
+}
+Long.fromInt = fromInt;
+function fromNumber(value, unsigned) {
+  if (isNaN(value))
+    return unsigned ? UZERO : ZERO;
+  if (unsigned) {
+    if (value < 0)
+      return UZERO;
+    if (value >= TWO_PWR_64_DBL)
+      return MAX_UNSIGNED_VALUE;
+  } else {
+    if (value <= -TWO_PWR_63_DBL)
+      return MIN_VALUE;
+    if (value + 1 >= TWO_PWR_63_DBL)
+      return MAX_VALUE;
+  }
+  if (value < 0)
+    return fromNumber(-value, unsigned).neg();
+  return fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
+}
+Long.fromNumber = fromNumber;
+function fromBits(lowBits, highBits, unsigned) {
+  return new Long(lowBits, highBits, unsigned);
+}
+Long.fromBits = fromBits;
+var pow_dbl = Math.pow;
+function fromString(str, unsigned, radix) {
+  if (str.length === 0)
+    throw Error("empty string");
+  if (typeof unsigned === "number") {
+    radix = unsigned;
+    unsigned = false;
+  } else {
+    unsigned = !!unsigned;
+  }
+  if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
+    return unsigned ? UZERO : ZERO;
+  radix = radix || 10;
+  if (radix < 2 || 36 < radix)
+    throw RangeError("radix");
+  var p;
+  if ((p = str.indexOf("-")) > 0)
+    throw Error("interior hyphen");
+  else if (p === 0) {
+    return fromString(str.substring(1), unsigned, radix).neg();
+  }
+  var radixToPower = fromNumber(pow_dbl(radix, 8));
+  var result = ZERO;
+  for (var i = 0; i < str.length; i += 8) {
+    var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);
+    if (size < 8) {
+      var power = fromNumber(pow_dbl(radix, size));
+      result = result.mul(power).add(fromNumber(value));
+    } else {
+      result = result.mul(radixToPower);
+      result = result.add(fromNumber(value));
+    }
+  }
+  result.unsigned = unsigned;
+  return result;
+}
+Long.fromString = fromString;
+function fromValue(val, unsigned) {
+  if (typeof val === "number")
+    return fromNumber(val, unsigned);
+  if (typeof val === "string")
+    return fromString(val, unsigned);
+  return fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned);
+}
+Long.fromValue = fromValue;
+var TWO_PWR_16_DBL = 1 << 16;
+var TWO_PWR_24_DBL = 1 << 24;
+var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
+var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
+var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
+var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
+var ZERO = fromInt(0);
+Long.ZERO = ZERO;
+var UZERO = fromInt(0, true);
+Long.UZERO = UZERO;
+var ONE = fromInt(1);
+Long.ONE = ONE;
+var UONE = fromInt(1, true);
+Long.UONE = UONE;
+var NEG_ONE = fromInt(-1);
+Long.NEG_ONE = NEG_ONE;
+var MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false);
+Long.MAX_VALUE = MAX_VALUE;
+var MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true);
+Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
+var MIN_VALUE = fromBits(0, 2147483648 | 0, false);
+Long.MIN_VALUE = MIN_VALUE;
+var LongPrototype = Long.prototype;
+LongPrototype.toInt = function toInt() {
+  return this.unsigned ? this.low >>> 0 : this.low;
+};
+LongPrototype.toNumber = function toNumber() {
+  if (this.unsigned)
+    return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
+  return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
+};
+LongPrototype.toString = function toString(radix) {
+  radix = radix || 10;
+  if (radix < 2 || 36 < radix)
+    throw RangeError("radix");
+  if (this.isZero())
+    return "0";
+  if (this.isNegative()) {
+    if (this.eq(MIN_VALUE)) {
+      var radixLong = fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this);
+      return div.toString(radix) + rem1.toInt().toString(radix);
+    } else
+      return "-" + this.neg().toString(radix);
+  }
+  var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this;
+  var result = "";
+  while (true) {
+    var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix);
+    rem = remDiv;
+    if (rem.isZero())
+      return digits + result;
+    else {
+      while (digits.length < 6)
+        digits = "0" + digits;
+      result = "" + digits + result;
+    }
+  }
+};
+LongPrototype.getHighBits = function getHighBits() {
+  return this.high;
+};
+LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
+  return this.high >>> 0;
+};
+LongPrototype.getLowBits = function getLowBits() {
+  return this.low;
+};
+LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
+  return this.low >>> 0;
+};
+LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
+  if (this.isNegative())
+    return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
+  var val = this.high != 0 ? this.high : this.low;
+  for (var bit = 31; bit > 0; bit--)
+    if ((val & 1 << bit) != 0)
+      break;
+  return this.high != 0 ? bit + 33 : bit + 1;
+};
+LongPrototype.isZero = function isZero() {
+  return this.high === 0 && this.low === 0;
+};
+LongPrototype.eqz = LongPrototype.isZero;
+LongPrototype.isNegative = function isNegative() {
+  return !this.unsigned && this.high < 0;
+};
+LongPrototype.isPositive = function isPositive() {
+  return this.unsigned || this.high >= 0;
+};
+LongPrototype.isOdd = function isOdd() {
+  return (this.low & 1) === 1;
+};
+LongPrototype.isEven = function isEven() {
+  return (this.low & 1) === 0;
+};
+LongPrototype.equals = function equals(other) {
+  if (!isLong(other))
+    other = fromValue(other);
+  if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
+    return false;
+  return this.high === other.high && this.low === other.low;
+};
+LongPrototype.eq = LongPrototype.equals;
+LongPrototype.notEquals = function notEquals(other) {
+  return !this.eq(
+    /* validates */
+    other
+  );
+};
+LongPrototype.neq = LongPrototype.notEquals;
+LongPrototype.ne = LongPrototype.notEquals;
+LongPrototype.lessThan = function lessThan(other) {
+  return this.comp(
+    /* validates */
+    other
+  ) < 0;
+};
+LongPrototype.lt = LongPrototype.lessThan;
+LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
+  return this.comp(
+    /* validates */
+    other
+  ) <= 0;
+};
+LongPrototype.lte = LongPrototype.lessThanOrEqual;
+LongPrototype.le = LongPrototype.lessThanOrEqual;
+LongPrototype.greaterThan = function greaterThan(other) {
+  return this.comp(
+    /* validates */
+    other
+  ) > 0;
+};
+LongPrototype.gt = LongPrototype.greaterThan;
+LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
+  return this.comp(
+    /* validates */
+    other
+  ) >= 0;
+};
+LongPrototype.gte = LongPrototype.greaterThanOrEqual;
+LongPrototype.ge = LongPrototype.greaterThanOrEqual;
+LongPrototype.compare = function compare(other) {
+  if (!isLong(other))
+    other = fromValue(other);
+  if (this.eq(other))
+    return 0;
+  var thisNeg = this.isNegative(), otherNeg = other.isNegative();
+  if (thisNeg && !otherNeg)
+    return -1;
+  if (!thisNeg && otherNeg)
+    return 1;
+  if (!this.unsigned)
+    return this.sub(other).isNegative() ? -1 : 1;
+  return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
+};
+LongPrototype.comp = LongPrototype.compare;
+LongPrototype.negate = function negate() {
+  if (!this.unsigned && this.eq(MIN_VALUE))
+    return MIN_VALUE;
+  return this.not().add(ONE);
+};
+LongPrototype.neg = LongPrototype.negate;
+LongPrototype.add = function add(addend) {
+  if (!isLong(addend))
+    addend = fromValue(addend);
+  var a48 = this.high >>> 16;
+  var a32 = this.high & 65535;
+  var a16 = this.low >>> 16;
+  var a00 = this.low & 65535;
+  var b48 = addend.high >>> 16;
+  var b32 = addend.high & 65535;
+  var b16 = addend.low >>> 16;
+  var b00 = addend.low & 65535;
+  var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+  c00 += a00 + b00;
+  c16 += c00 >>> 16;
+  c00 &= 65535;
+  c16 += a16 + b16;
+  c32 += c16 >>> 16;
+  c16 &= 65535;
+  c32 += a32 + b32;
+  c48 += c32 >>> 16;
+  c32 &= 65535;
+  c48 += a48 + b48;
+  c48 &= 65535;
+  return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+};
+LongPrototype.subtract = function subtract(subtrahend) {
+  if (!isLong(subtrahend))
+    subtrahend = fromValue(subtrahend);
+  return this.add(subtrahend.neg());
+};
+LongPrototype.sub = LongPrototype.subtract;
+LongPrototype.multiply = function multiply(multiplier) {
+  if (this.isZero())
+    return this;
+  if (!isLong(multiplier))
+    multiplier = fromValue(multiplier);
+  if (wasm) {
+    var low = wasm["mul"](
+      this.low,
+      this.high,
+      multiplier.low,
+      multiplier.high
+    );
+    return fromBits(low, wasm["get_high"](), this.unsigned);
+  }
+  if (multiplier.isZero())
+    return this.unsigned ? UZERO : ZERO;
+  if (this.eq(MIN_VALUE))
+    return multiplier.isOdd() ? MIN_VALUE : ZERO;
+  if (multiplier.eq(MIN_VALUE))
+    return this.isOdd() ? MIN_VALUE : ZERO;
+  if (this.isNegative()) {
+    if (multiplier.isNegative())
+      return this.neg().mul(multiplier.neg());
+    else
+      return this.neg().mul(multiplier).neg();
+  } else if (multiplier.isNegative())
+    return this.mul(multiplier.neg()).neg();
+  if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
+    return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
+  var a48 = this.high >>> 16;
+  var a32 = this.high & 65535;
+  var a16 = this.low >>> 16;
+  var a00 = this.low & 65535;
+  var b48 = multiplier.high >>> 16;
+  var b32 = multiplier.high & 65535;
+  var b16 = multiplier.low >>> 16;
+  var b00 = multiplier.low & 65535;
+  var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+  c00 += a00 * b00;
+  c16 += c00 >>> 16;
+  c00 &= 65535;
+  c16 += a16 * b00;
+  c32 += c16 >>> 16;
+  c16 &= 65535;
+  c16 += a00 * b16;
+  c32 += c16 >>> 16;
+  c16 &= 65535;
+  c32 += a32 * b00;
+  c48 += c32 >>> 16;
+  c32 &= 65535;
+  c32 += a16 * b16;
+  c48 += c32 >>> 16;
+  c32 &= 65535;
+  c32 += a00 * b32;
+  c48 += c32 >>> 16;
+  c32 &= 65535;
+  c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+  c48 &= 65535;
+  return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+};
+LongPrototype.mul = LongPrototype.multiply;
+LongPrototype.divide = function divide(divisor) {
+  if (!isLong(divisor))
+    divisor = fromValue(divisor);
+  if (divisor.isZero())
+    throw Error("division by zero");
+  if (wasm) {
+    if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
+      return this;
+    }
+    var low = (this.unsigned ? wasm["div_u"] : wasm["div_s"])(
+      this.low,
+      this.high,
+      divisor.low,
+      divisor.high
+    );
+    return fromBits(low, wasm["get_high"](), this.unsigned);
+  }
+  if (this.isZero())
+    return this.unsigned ? UZERO : ZERO;
+  var approx, rem, res;
+  if (!this.unsigned) {
+    if (this.eq(MIN_VALUE)) {
+      if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
+        return MIN_VALUE;
+      else if (divisor.eq(MIN_VALUE))
+        return ONE;
+      else {
+        var halfThis = this.shr(1);
+        approx = halfThis.div(divisor).shl(1);
+        if (approx.eq(ZERO)) {
+          return divisor.isNegative() ? ONE : NEG_ONE;
+        } else {
+          rem = this.sub(divisor.mul(approx));
+          res = approx.add(rem.div(divisor));
+          return res;
+        }
+      }
+    } else if (divisor.eq(MIN_VALUE))
+      return this.unsigned ? UZERO : ZERO;
+    if (this.isNegative()) {
+      if (divisor.isNegative())
+        return this.neg().div(divisor.neg());
+      return this.neg().div(divisor).neg();
+    } else if (divisor.isNegative())
+      return this.div(divisor.neg()).neg();
+    res = ZERO;
+  } else {
+    if (!divisor.unsigned)
+      divisor = divisor.toUnsigned();
+    if (divisor.gt(this))
+      return UZERO;
+    if (divisor.gt(this.shru(1)))
+      return UONE;
+    res = UZERO;
+  }
+  rem = this;
+  while (rem.gte(divisor)) {
+    approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
+    var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor);
+    while (approxRem.isNegative() || approxRem.gt(rem)) {
+      approx -= delta;
+      approxRes = fromNumber(approx, this.unsigned);
+      approxRem = approxRes.mul(divisor);
+    }
+    if (approxRes.isZero())
+      approxRes = ONE;
+    res = res.add(approxRes);
+    rem = rem.sub(approxRem);
+  }
+  return res;
+};
+LongPrototype.div = LongPrototype.divide;
+LongPrototype.modulo = function modulo(divisor) {
+  if (!isLong(divisor))
+    divisor = fromValue(divisor);
+  if (wasm) {
+    var low = (this.unsigned ? wasm["rem_u"] : wasm["rem_s"])(
+      this.low,
+      this.high,
+      divisor.low,
+      divisor.high
+    );
+    return fromBits(low, wasm["get_high"](), this.unsigned);
+  }
+  return this.sub(this.div(divisor).mul(divisor));
+};
+LongPrototype.mod = LongPrototype.modulo;
+LongPrototype.rem = LongPrototype.modulo;
+LongPrototype.not = function not() {
+  return fromBits(~this.low, ~this.high, this.unsigned);
+};
+LongPrototype.countLeadingZeros = function countLeadingZeros() {
+  return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;
+};
+LongPrototype.clz = LongPrototype.countLeadingZeros;
+LongPrototype.countTrailingZeros = function countTrailingZeros() {
+  return this.low ? ctz32(this.low) : ctz32(this.high) + 32;
+};
+LongPrototype.ctz = LongPrototype.countTrailingZeros;
+LongPrototype.and = function and(other) {
+  if (!isLong(other))
+    other = fromValue(other);
+  return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
+};
+LongPrototype.or = function or(other) {
+  if (!isLong(other))
+    other = fromValue(other);
+  return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
+};
+LongPrototype.xor = function xor(other) {
+  if (!isLong(other))
+    other = fromValue(other);
+  return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
+};
+LongPrototype.shiftLeft = function shiftLeft(numBits) {
+  if (isLong(numBits))
+    numBits = numBits.toInt();
+  if ((numBits &= 63) === 0)
+    return this;
+  else if (numBits < 32)
+    return fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned);
+  else
+    return fromBits(0, this.low << numBits - 32, this.unsigned);
+};
+LongPrototype.shl = LongPrototype.shiftLeft;
+LongPrototype.shiftRight = function shiftRight(numBits) {
+  if (isLong(numBits))
+    numBits = numBits.toInt();
+  if ((numBits &= 63) === 0)
+    return this;
+  else if (numBits < 32)
+    return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned);
+  else
+    return fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+};
+LongPrototype.shr = LongPrototype.shiftRight;
+LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
+  if (isLong(numBits))
+    numBits = numBits.toInt();
+  if ((numBits &= 63) === 0)
+    return this;
+  if (numBits < 32)
+    return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >>> numBits, this.unsigned);
+  if (numBits === 32)
+    return fromBits(this.high, 0, this.unsigned);
+  return fromBits(this.high >>> numBits - 32, 0, this.unsigned);
+};
+LongPrototype.shru = LongPrototype.shiftRightUnsigned;
+LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
+LongPrototype.rotateLeft = function rotateLeft(numBits) {
+  var b;
+  if (isLong(numBits))
+    numBits = numBits.toInt();
+  if ((numBits &= 63) === 0)
+    return this;
+  if (numBits === 32)
+    return fromBits(this.high, this.low, this.unsigned);
+  if (numBits < 32) {
+    b = 32 - numBits;
+    return fromBits(this.low << numBits | this.high >>> b, this.high << numBits | this.low >>> b, this.unsigned);
+  }
+  numBits -= 32;
+  b = 32 - numBits;
+  return fromBits(this.high << numBits | this.low >>> b, this.low << numBits | this.high >>> b, this.unsigned);
+};
+LongPrototype.rotl = LongPrototype.rotateLeft;
+LongPrototype.rotateRight = function rotateRight(numBits) {
+  var b;
+  if (isLong(numBits))
+    numBits = numBits.toInt();
+  if ((numBits &= 63) === 0)
+    return this;
+  if (numBits === 32)
+    return fromBits(this.high, this.low, this.unsigned);
+  if (numBits < 32) {
+    b = 32 - numBits;
+    return fromBits(this.high << b | this.low >>> numBits, this.low << b | this.high >>> numBits, this.unsigned);
+  }
+  numBits -= 32;
+  b = 32 - numBits;
+  return fromBits(this.low << b | this.high >>> numBits, this.high << b | this.low >>> numBits, this.unsigned);
+};
+LongPrototype.rotr = LongPrototype.rotateRight;
+LongPrototype.toSigned = function toSigned() {
+  if (!this.unsigned)
+    return this;
+  return fromBits(this.low, this.high, false);
+};
+LongPrototype.toUnsigned = function toUnsigned() {
+  if (this.unsigned)
+    return this;
+  return fromBits(this.low, this.high, true);
+};
+LongPrototype.toBytes = function toBytes(le) {
+  return le ? this.toBytesLE() : this.toBytesBE();
+};
+LongPrototype.toBytesLE = function toBytesLE() {
+  var hi = this.high, lo = this.low;
+  return [
+    lo & 255,
+    lo >>> 8 & 255,
+    lo >>> 16 & 255,
+    lo >>> 24,
+    hi & 255,
+    hi >>> 8 & 255,
+    hi >>> 16 & 255,
+    hi >>> 24
+  ];
+};
+LongPrototype.toBytesBE = function toBytesBE() {
+  var hi = this.high, lo = this.low;
+  return [
+    hi >>> 24,
+    hi >>> 16 & 255,
+    hi >>> 8 & 255,
+    hi & 255,
+    lo >>> 24,
+    lo >>> 16 & 255,
+    lo >>> 8 & 255,
+    lo & 255
+  ];
+};
+Long.fromBytes = function fromBytes(bytes, unsigned, le) {
+  return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
+};
+Long.fromBytesLE = function fromBytesLE(bytes, unsigned) {
+  return new Long(
+    bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24,
+    bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24,
+    unsigned
+  );
+};
+Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
+  return new Long(
+    bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7],
+    bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3],
+    unsigned
+  );
+};
+var long_default = Long;
+
+// ../services/protobuf/ts/faucet/faucet.ts
+var import_minimal = __toESM(require_minimal2(), 1);
+function createBaseLinkedTwitterPair() {
+  return { username: "", address: "" };
+}
+var LinkedTwitterPair = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.username !== "") {
+      writer.uint32(10).string(message.username);
+    }
+    if (message.address !== "") {
+      writer.uint32(18).string(message.address);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseLinkedTwitterPair();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.username = reader.string();
+          break;
+        case 2:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseLinkedTwitterPair();
+    message.username = object.username ?? "";
+    message.address = object.address ?? "";
+    return message;
+  }
+};
+function createBaseDripRequest() {
+  return { username: "", address: "" };
+}
+var DripRequest = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.username !== "") {
+      writer.uint32(10).string(message.username);
+    }
+    if (message.address !== "") {
+      writer.uint32(18).string(message.address);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDripRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.username = reader.string();
+          break;
+        case 2:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseDripRequest();
+    message.username = object.username ?? "";
+    message.address = object.address ?? "";
+    return message;
+  }
+};
+function createBaseDripDevRequest() {
+  return { address: "" };
+}
+var DripDevRequest = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDripDevRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseDripDevRequest();
+    message.address = object.address ?? "";
+    return message;
+  }
+};
+function createBaseDripResponse() {
+  return { dripTxHash: "", ecsTxHash: "" };
+}
+var DripResponse = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.dripTxHash !== "") {
+      writer.uint32(10).string(message.dripTxHash);
+    }
+    if (message.ecsTxHash !== "") {
+      writer.uint32(18).string(message.ecsTxHash);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDripResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.dripTxHash = reader.string();
+          break;
+        case 2:
+          message.ecsTxHash = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseDripResponse();
+    message.dripTxHash = object.dripTxHash ?? "";
+    message.ecsTxHash = object.ecsTxHash ?? "";
+    return message;
+  }
+};
+function createBaseTimeUntilDripResponse() {
+  return { timeUntilDripMinutes: 0, timeUntilDripSeconds: 0 };
+}
+var TimeUntilDripResponse = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.timeUntilDripMinutes !== 0) {
+      writer.uint32(9).double(message.timeUntilDripMinutes);
+    }
+    if (message.timeUntilDripSeconds !== 0) {
+      writer.uint32(17).double(message.timeUntilDripSeconds);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTimeUntilDripResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.timeUntilDripMinutes = reader.double();
+          break;
+        case 2:
+          message.timeUntilDripSeconds = reader.double();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseTimeUntilDripResponse();
+    message.timeUntilDripMinutes = object.timeUntilDripMinutes ?? 0;
+    message.timeUntilDripSeconds = object.timeUntilDripSeconds ?? 0;
+    return message;
+  }
+};
+function createBaseGetLinkedTwittersRequest() {
+  return {};
+}
+var GetLinkedTwittersRequest = {
+  encode(_, writer = import_minimal.default.Writer.create()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGetLinkedTwittersRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_) {
+    const message = createBaseGetLinkedTwittersRequest();
+    return message;
+  }
+};
+function createBaseGetLinkedTwittersResponse() {
+  return { linkedTwitters: [] };
+}
+var GetLinkedTwittersResponse = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    for (const v of message.linkedTwitters) {
+      LinkedTwitterPair.encode(v, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGetLinkedTwittersResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.linkedTwitters.push(LinkedTwitterPair.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseGetLinkedTwittersResponse();
+    message.linkedTwitters = object.linkedTwitters?.map((e) => LinkedTwitterPair.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseLinkedTwitterForAddressRequest() {
+  return { address: "" };
+}
+var LinkedTwitterForAddressRequest = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseLinkedTwitterForAddressRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseLinkedTwitterForAddressRequest();
+    message.address = object.address ?? "";
+    return message;
+  }
+};
+function createBaseLinkedTwitterForAddressResponse() {
+  return { username: "" };
+}
+var LinkedTwitterForAddressResponse = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.username !== "") {
+      writer.uint32(10).string(message.username);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseLinkedTwitterForAddressResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.username = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseLinkedTwitterForAddressResponse();
+    message.username = object.username ?? "";
+    return message;
+  }
+};
+function createBaseLinkedAddressForTwitterRequest() {
+  return { username: "" };
+}
+var LinkedAddressForTwitterRequest = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.username !== "") {
+      writer.uint32(10).string(message.username);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseLinkedAddressForTwitterRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.username = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseLinkedAddressForTwitterRequest();
+    message.username = object.username ?? "";
+    return message;
+  }
+};
+function createBaseLinkedAddressForTwitterResponse() {
+  return { address: "" };
+}
+var LinkedAddressForTwitterResponse = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseLinkedAddressForTwitterResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseLinkedAddressForTwitterResponse();
+    message.address = object.address ?? "";
+    return message;
+  }
+};
+function createBaseSetLinkedTwitterRequest() {
+  return { address: "", username: "", signature: "" };
+}
+var SetLinkedTwitterRequest = {
+  encode(message, writer = import_minimal.default.Writer.create()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.username !== "") {
+      writer.uint32(18).string(message.username);
+    }
+    if (message.signature !== "") {
+      writer.uint32(26).string(message.signature);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSetLinkedTwitterRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.username = reader.string();
+          break;
+        case 3:
+          message.signature = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    const message = createBaseSetLinkedTwitterRequest();
+    message.address = object.address ?? "";
+    message.username = object.username ?? "";
+    message.signature = object.signature ?? "";
+    return message;
+  }
+};
+function createBaseSetLinkedTwitterResponse() {
+  return {};
+}
+var SetLinkedTwitterResponse = {
+  encode(_, writer = import_minimal.default.Writer.create()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal.default.Reader ? input : new import_minimal.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSetLinkedTwitterResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_) {
+    const message = createBaseSetLinkedTwitterResponse();
+    return message;
+  }
+};
+var FaucetServiceDefinition = {
+  name: "FaucetService",
+  fullName: "faucet.FaucetService",
+  methods: {
+    drip: {
+      name: "Drip",
+      requestType: DripRequest,
+      requestStream: false,
+      responseType: DripResponse,
+      responseStream: false,
+      options: {}
+    },
+    dripDev: {
+      name: "DripDev",
+      requestType: DripDevRequest,
+      requestStream: false,
+      responseType: DripResponse,
+      responseStream: false,
+      options: {}
+    },
+    dripVerifyTweet: {
+      name: "DripVerifyTweet",
+      requestType: DripRequest,
+      requestStream: false,
+      responseType: DripResponse,
+      responseStream: false,
+      options: {}
+    },
+    timeUntilDrip: {
+      name: "TimeUntilDrip",
+      requestType: DripRequest,
+      requestStream: false,
+      responseType: TimeUntilDripResponse,
+      responseStream: false,
+      options: {}
+    },
+    getLinkedTwitters: {
+      name: "GetLinkedTwitters",
+      requestType: GetLinkedTwittersRequest,
+      requestStream: false,
+      responseType: GetLinkedTwittersResponse,
+      responseStream: false,
+      options: {}
+    },
+    getLinkedTwitterForAddress: {
+      name: "GetLinkedTwitterForAddress",
+      requestType: LinkedTwitterForAddressRequest,
+      requestStream: false,
+      responseType: LinkedTwitterForAddressResponse,
+      responseStream: false,
+      options: {}
+    },
+    getLinkedAddressForTwitter: {
+      name: "GetLinkedAddressForTwitter",
+      requestType: LinkedAddressForTwitterRequest,
+      requestStream: false,
+      responseType: LinkedAddressForTwitterResponse,
+      responseStream: false,
+      options: {}
+    },
+    /** Admin utility endpoints for modifying state. Requires a signature with faucet private key. */
+    setLinkedTwitter: {
+      name: "SetLinkedTwitter",
+      requestType: SetLinkedTwitterRequest,
+      requestStream: false,
+      responseType: SetLinkedTwitterResponse,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+var globalThis = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+if (import_minimal.default.util.Long !== long_default) {
+  import_minimal.default.util.Long = long_default;
+  import_minimal.default.configure();
+}
+
+// src/commands/faucet.ts
+import { createChannel, createClient } from "nice-grpc-web";
+import chalk from "chalk";
+import { NodeHttpTransport } from "@improbable-eng/grpc-web-node-http-transport";
+function createFaucetService(url) {
+  return createClient(FaucetServiceDefinition, createChannel(url, NodeHttpTransport()));
+}
+var commandModule2 = {
+  command: "faucet",
+  describe: "Interact with a MUD faucet",
+  builder(yargs) {
+    return yargs.options({
+      dripDev: {
+        type: "boolean",
+        desc: "Request a drip from the dev endpoint (requires faucet to have dev mode enabled)",
+        default: true
+      },
+      faucetUrl: {
+        type: "string",
+        desc: "URL of the MUD faucet",
+        default: "https://faucet.testnet-mud-services.linfra.xyz"
+      },
+      address: {
+        type: "string",
+        desc: "Ethereum address to fund",
+        required: true
+      }
+    });
+  },
+  async handler({ dripDev, faucetUrl, address }) {
+    const faucet = createFaucetService(faucetUrl);
+    if (dripDev) {
+      console.log(chalk.yellow("Dripping to", address));
+      await faucet.dripDev({ address });
+      console.log(chalk.yellow("Success"));
+    }
+    process.exit(0);
+  }
+};
+var faucet_default = commandModule2;
+
+// src/commands/gas-report.ts
+import { readFileSync, writeFileSync, rmSync as rmSync2 } from "fs";
+import { execa } from "execa";
+import chalk2 from "chalk";
+import { table, getBorderCharacters } from "table";
+var commandModule3 = {
+  command: "gas-report",
+  describe: "Create a gas report",
+  builder(yargs) {
+    return yargs.options({
+      path: { type: "array", string: true, default: ["Gas.t.sol"], desc: "File containing the gas tests" },
+      save: { type: "string", desc: "Save the gas report to a file" },
+      compare: { type: "string", desc: "Compare to an existing gas report" }
+    });
+  },
+  async handler({ path: path6, save, compare: compare2 }) {
+    let gasReport = [];
+    for (const file of path6) {
+      gasReport = gasReport.concat(await runGasReport(file));
+    }
+    const compareGasReport = [];
+    if (compare2) {
+      try {
+        const compareFileContents = readFileSync(compare2, "utf8");
+        const compareGasReportRegex = new RegExp(/\((.*)\) \| (.*) \[(.*)\]: (.*)/g);
+        let compareGasReportMatch;
+        while ((compareGasReportMatch = compareGasReportRegex.exec(compareFileContents)) !== null) {
+          const source = compareGasReportMatch[1];
+          const name = compareGasReportMatch[2];
+          const functionCall = compareGasReportMatch[3];
+          const gasUsed = compareGasReportMatch[4];
+          compareGasReport.push({ source, name, functionCall, gasUsed: parseInt(gasUsed) });
+        }
+      } catch {
+        console.log(chalk2.red(`Gas report to compare not found: ${compare2}`));
+        compare2 = void 0;
+      }
+    }
+    gasReport = gasReport.map((entry) => {
+      const prevEntry = compareGasReport.find((e) => e.name === entry.name && e.functionCall === entry.functionCall);
+      return { ...entry, prevGasUsed: prevEntry?.gasUsed };
+    });
+    printGasReport(gasReport, compare2);
+    if (save)
+      saveGasReport(gasReport, save);
+    process.exit(0);
+  }
+};
+var gas_report_default = commandModule3;
+async function runGasReport(path6) {
+  if (!path6.endsWith(".t.sol")) {
+    console.log("Skipping gas report for", chalk2.bold(path6), "(not a test file)");
+    return [];
+  }
+  console.log("Running gas report for", chalk2.bold(path6));
+  const gasReport = [];
+  const fileContents = readFileSync(path6, "utf8");
+  let newFile = fileContents;
+  const functionRegex = new RegExp(/function (.*){/g);
+  let functionMatch;
+  while ((functionMatch = functionRegex.exec(fileContents)) !== null) {
+    const functionSignature = functionMatch[0];
+    newFile = newFile.replace(functionSignature, `${functionSignature}
+uint256 _gasreport;`);
+  }
+  const regex = new RegExp(/\/\/ !gasreport (.*)\n(.*)/g);
+  let match;
+  while ((match = regex.exec(fileContents)) !== null) {
+    const name = match[1];
+    const functionCall = match[2].trim();
+    newFile = newFile.replace(
+      match[0],
+      `
+_gasreport = gasleft();
+${functionCall}
+_gasreport = _gasreport - gasleft();
+console.log("GAS REPORT: ${name} [${functionCall.replaceAll('"', '\\"')}]:", _gasreport);`
+    );
+  }
+  newFile = newFile.replace(/pure/g, "view");
+  const tempFileName = path6.replace(/\.t\.sol$/, "MudGasReport.t.sol");
+  writeFileSync(tempFileName, newFile);
+  const child = execa("forge", ["test", "--match-path", tempFileName, "-vvv"], {
+    stdio: ["inherit", "pipe", "inherit"]
+  });
+  let logs = "";
+  try {
+    logs = (await child).stdout;
+    rmSync2(tempFileName);
+  } catch (e) {
+    console.log(e.stdout ?? e);
+    console.log(chalk2.red("\n-----------\nError while running the gas report (see above)"));
+    rmSync2(tempFileName);
+    process.exit();
+  }
+  const gasReportRegex = new RegExp(/GAS REPORT: (.*) \[(.*)\]: (.*)/g);
+  let gasReportMatch;
+  while ((gasReportMatch = gasReportRegex.exec(logs)) !== null) {
+    const name = gasReportMatch[1];
+    const functionCall = gasReportMatch[2].replace(";", "");
+    const gasUsed = gasReportMatch[3];
+    gasReport.push({ source: path6, name, functionCall, gasUsed: parseInt(gasUsed) });
+  }
+  return gasReport;
+}
+function printGasReport(gasReport, compare2) {
+  if (compare2)
+    console.log(chalk2.bold(`Gas report compared to ${compare2}`));
+  const headers = [
+    chalk2.bold("Source"),
+    chalk2.bold("Name"),
+    chalk2.bold("Function call"),
+    chalk2.bold("Gas used"),
+    ...compare2 ? [chalk2.bold("Prev gas used"), chalk2.bold("Difference")] : []
+  ];
+  const values = gasReport.map((entry) => {
+    const diff = entry.prevGasUsed ? entry.gasUsed - entry.prevGasUsed : 0;
+    const diffEntry = diff > 0 ? chalk2.red(`+${diff}`) : diff < 0 ? chalk2.green(`${diff}`) : diff;
+    const compareColumns = compare2 ? [entry.prevGasUsed ?? "n/a", diffEntry] : [];
+    const gasUsedEntry = diff > 0 ? chalk2.red(entry.gasUsed) : diff < 0 ? chalk2.green(entry.gasUsed) : entry.gasUsed;
+    return [entry.source, entry.name, entry.functionCall, gasUsedEntry, ...compareColumns];
+  });
+  const rows = [headers, ...values];
+  console.log(table(rows, { border: getBorderCharacters("norc") }));
+}
+function saveGasReport(gasReport, path6) {
+  console.log(chalk2.bold(`Saving gas report to ${path6}`));
+  const serializedGasReport = gasReport.map((entry) => `(${entry.source}) | ${entry.name} [${entry.functionCall}]: ${entry.gasUsed}`).join("\n");
+  writeFileSync(path6, serializedGasReport);
+}
+
+// src/commands/hello.ts
+var commandModule4 = {
+  command: "hello <name>",
+  describe: "Greet <name> with Hello",
+  builder(yargs) {
+    return yargs.options({
+      upper: { type: "boolean" }
+    }).positional("name", { type: "string", demandOption: true });
+  },
+  handler({ name }) {
+    const greeting = `Gm, ${name}!`;
+    console.log(greeting);
+    process.exit(0);
+  }
+};
+var hello_default = commandModule4;
+
+// src/commands/tablegen.ts
+var commandModule5 = {
+  command: "tablegen",
+  describe: "Autogenerate MUD Store table libraries based on the config file",
+  builder(yargs) {
+    return yargs.options({
+      configPath: { type: "string", desc: "Path to the config file" }
+    });
+  },
+  async handler({ configPath }) {
+    const srcDirectory = await getSrcDirectory();
+    const config = await loadStoreConfig(configPath);
+    await tablegen(config, srcDirectory);
+    process.exit(0);
+  }
+};
+var tablegen_default = commandModule5;
+
+// src/commands/tsgen.ts
+var commandModule6 = {
+  command: "tsgen",
+  describe: "Autogenerate MUD typescript definitions based on the config file",
+  builder(yargs) {
+    return yargs.options({
+      configPath: { type: "string", demandOption: true, desc: "Path to the config file" },
+      out: { type: "string", demandOption: true, desc: "Directory to output MUD typescript definition files" }
+    });
+  },
+  async handler(args) {
+    const { configPath, out } = args;
+    const config = await loadStoreConfig(configPath);
+    await tsgen(config, out);
+    process.exit(0);
+  }
+};
+var tsgen_default = commandModule6;
+
+// src/commands/deploy-v2.ts
+import chalk3 from "chalk";
+import glob from "glob";
+import path2, { basename } from "path";
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+
+// src/utils/getChainId.ts
+import { ethers } from "ethers";
+async function getChainId(rpc) {
+  const { result: chainId } = await ethers.utils.fetchJson(
+    rpc,
+    '{ "id": 42, "jsonrpc": "2.0", "method": "eth_chainId", "params": [ ] }'
+  );
+  return Number(chainId);
+}
+
+// src/commands/deploy-v2.ts
+var yDeployOptions = {
+  configPath: { type: "string", desc: "Path to the config file" },
+  clean: { type: "boolean", desc: "Remove the build forge artifacts and cache directories before building" },
+  printConfig: { type: "boolean", desc: "Print the resolved config" },
+  profile: { type: "string", desc: "The foundry profile to use" },
+  debug: { type: "boolean", desc: "Print debug logs, like full error messages" },
+  priorityFeeMultiplier: {
+    type: "number",
+    desc: "Multiply the estimated priority fee by the provided factor",
+    default: 1
+  },
+  saveDeployment: { type: "boolean", desc: "Save the deployment info to a file", default: true },
+  rpc: { type: "string", desc: "The RPC URL to use. Defaults to the RPC url from the local foundry.toml" }
+};
+async function deployHandler(args) {
+  args.profile = args.profile ?? process.env.FOUNDRY_PROFILE;
+  const { configPath, printConfig, profile, clean } = args;
+  const rpc = args.rpc ?? await getRpcUrl(profile);
+  console.log(
+    chalk3.bgBlue(
+      chalk3.whiteBright(`
+ Deploying MUD v2 contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} 
+`)
+    )
+  );
+  if (clean)
+    await forge(["clean"], { profile });
+  await forge(["build"], { profile });
+  const srcDir = await getSrcDirectory();
+  const existingContracts = glob.sync(`${srcDir}/**/*.sol`).map((path6) => basename(path6, ".sol"));
+  const worldConfig = await loadWorldConfig(configPath, existingContracts);
+  const storeConfig = await loadStoreConfig(configPath);
+  const mudConfig = { ...worldConfig, ...storeConfig };
+  if (printConfig)
+    console.log(chalk3.green("\nResolved config:\n"), JSON.stringify(mudConfig, null, 2));
+  try {
+    const privateKey = process.env.PRIVATE_KEY;
+    if (!privateKey)
+      throw new MUDError("Missing PRIVATE_KEY environment variable");
+    const deploymentInfo = await deploy(mudConfig, { ...args, rpc, privateKey });
+    if (args.saveDeployment) {
+      const chainId = await getChainId(rpc);
+      const outputDir = path2.join(mudConfig.deploysDirectory, chainId.toString());
+      mkdirSync(outputDir, { recursive: true });
+      writeFileSync2(path2.join(outputDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2));
+      writeFileSync2(path2.join(outputDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2));
+      console.log(chalk3.bgGreen(chalk3.whiteBright(`
+ Deployment result (written to ${outputDir}): 
+`)));
+    }
+    console.log(deploymentInfo);
+    return deploymentInfo;
+  } catch (error) {
+    logError(error);
+    process.exit(1);
+  }
+}
+var commandModule7 = {
+  command: "deploy-v2",
+  describe: "Deploy MUD v2 contracts",
+  builder(yargs) {
+    return yargs.options(yDeployOptions);
+  },
+  async handler(args) {
+    await deployHandler(args);
+    process.exit(0);
+  }
+};
+var deploy_v2_default = commandModule7;
+
+// src/commands/worldgen.ts
+import glob2 from "glob";
+import path4, { basename as basename2 } from "path";
+
+// src/render-solidity/worldgen.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path3 from "path";
+
+// src/utils/contractToInterface.ts
+import { parse, visit } from "@solidity-parser/parser";
+function contractToInterface(data, contractName) {
+  const ast = parse(data);
+  let withContract = false;
+  let symbols = [];
+  const functions = [];
+  visit(ast, {
+    ContractDefinition({ name }) {
+      if (name === contractName) {
+        withContract = true;
+      }
+    },
+    FunctionDefinition({ name, visibility, parameters, returnParameters, isConstructor, isFallback, isReceiveEther }, parent) {
+      if (parent !== void 0 && parent.type === "ContractDefinition" && parent.name === contractName) {
+        try {
+          if (isConstructor || isFallback || isReceiveEther)
+            return;
+          if (visibility === "default")
+            throw new MUDError(`Visibility is not specified`);
+          if (visibility === "external" || visibility === "public") {
+            functions.push({
+              name: name === null ? "" : name,
+              parameters: parameters.map(parseParameter),
+              returnParameters: returnParameters === null ? [] : returnParameters.map(parseParameter)
+            });
+            for (const { typeName } of parameters.concat(returnParameters ?? [])) {
+              symbols = symbols.concat(typeNameToExternalSymbols(typeName));
+            }
+          }
+        } catch (error) {
+          if (error instanceof MUDError) {
+            error.message = `Function "${name}" in contract "${contractName}": ${error.message}`;
+          }
+          throw error;
+        }
+      }
+    }
+  });
+  if (!withContract) {
+    throw new MUDError(`Contract not found: ${contractName}`);
+  }
+  return {
+    functions,
+    symbols
+  };
+}
+function parseParameter({ name, typeName, storageLocation }) {
+  let typedNameWithLocation = "";
+  const { name: flattenedTypeName, stateMutability } = flattenTypeName(typeName);
+  typedNameWithLocation += flattenedTypeName;
+  if (stateMutability !== null) {
+    typedNameWithLocation += ` ${stateMutability}`;
+  }
+  if (storageLocation !== null) {
+    typedNameWithLocation += ` ${storageLocation}`;
+  }
+  if (name !== null) {
+    typedNameWithLocation += ` ${name}`;
+  }
+  return typedNameWithLocation;
+}
+function flattenTypeName(typeName) {
+  if (typeName === null) {
+    return {
+      name: "",
+      stateMutability: null
+    };
+  }
+  if (typeName.type === "ElementaryTypeName") {
+    return {
+      name: typeName.name,
+      stateMutability: typeName.stateMutability
+    };
+  } else if (typeName.type === "UserDefinedTypeName") {
+    return {
+      name: typeName.namePath,
+      stateMutability: null
+    };
+  } else if (typeName.type === "ArrayTypeName") {
+    const length = typeName.length?.type === "NumberLiteral" ? typeName.length.number : "";
+    const { name, stateMutability } = flattenTypeName(typeName.baseTypeName);
+    return {
+      name: `${name}[${length}]`,
+      stateMutability
+    };
+  } else {
+    throw new MUDError(`Invalid typeName.type ${typeName.type}`);
+  }
+}
+function typeNameToExternalSymbols(typeName) {
+  if (typeName?.type === "UserDefinedTypeName") {
+    const symbol = typeName.namePath.split(".")[0];
+    return [symbol];
+  } else if (typeName?.type === "ArrayTypeName") {
+    return typeNameToExternalSymbols(typeName.baseTypeName);
+  } else {
+    return [];
+  }
+}
+
+// src/render-solidity/renderSystemInterface.ts
+function renderSystemInterface(options) {
+  const { imports, name, functionPrefix, functions } = options;
+  return `${renderedSolidityHeader}
+
+${renderImports(imports)}
+
+interface ${name} {
+  ${renderList(
+    functions,
+    ({ name: name2, parameters, returnParameters }) => `
+    function ${functionPrefix}${name2}(${renderArguments(parameters)}) external ${renderReturnParameters(
+      returnParameters
+    )};
+  `
+  )}
+}
+
+`;
+}
+function renderReturnParameters(returnParameters) {
+  if (returnParameters.length > 0) {
+    return `returns (${renderArguments(returnParameters)})`;
+  } else {
+    return "";
+  }
+}
+
+// src/render-solidity/renderWorld.ts
+function renderWorld(options) {
+  const { interfaceName, storeImportPath, worldImportPath, imports } = options;
+  return `${renderedSolidityHeader}
+
+import { IStore } from "${storeImportPath}IStore.sol";
+
+import { IWorldCore } from "${worldImportPath}interfaces/IWorldCore.sol";
+
+${renderImports(imports)}
+
+/**
+ * The ${interfaceName} interface includes all systems dynamically added to the World
+ * during the deploy process.
+ */
+interface ${interfaceName} is ${renderArguments(["IStore", "IWorldCore", ...imports.map(({ symbol }) => symbol)])} {
+
+}
+
+`;
+}
+
+// src/render-solidity/worldgen.ts
+async function worldgen(config, existingContracts, outputBaseDirectory) {
+  const worldgenBaseDirectory = path3.join(outputBaseDirectory, config.worldgenDirectory);
+  const systems = existingContracts.filter(({ basename: basename3 }) => Object.keys(config.systems).includes(basename3));
+  const systemInterfaceImports = [];
+  for (const system of systems) {
+    const data = readFileSync2(system.path, "utf8");
+    const { functions, symbols } = contractToInterface(data, system.basename);
+    const imports = symbols.map((symbol) => ({
+      symbol,
+      fromPath: system.path,
+      usedInPath: worldgenBaseDirectory
+    }));
+    const systemInterfaceName = `I${system.basename}`;
+    const { fileSelector } = config.systems[system.basename];
+    const output2 = renderSystemInterface({
+      name: systemInterfaceName,
+      functionPrefix: config.namespace === "" ? "" : `${config.namespace}_${fileSelector}_`,
+      functions,
+      imports
+    });
+    const fullOutputPath2 = path3.join(worldgenBaseDirectory, systemInterfaceName + ".sol");
+    await formatAndWriteSolidity(output2, fullOutputPath2, "Generated system interface");
+    systemInterfaceImports.push({
+      symbol: systemInterfaceName,
+      fromPath: `${systemInterfaceName}.sol`,
+      usedInPath: "./"
+    });
+  }
+  const output = renderWorld({
+    interfaceName: config.worldInterfaceName,
+    imports: systemInterfaceImports,
+    storeImportPath: config.storeImportPath,
+    worldImportPath: config.worldImportPath
+  });
+  const fullOutputPath = path3.join(worldgenBaseDirectory, config.worldInterfaceName + ".sol");
+  await formatAndWriteSolidity(output, fullOutputPath, "Generated system interface");
+}
+
+// src/commands/worldgen.ts
+import { rmSync as rmSync3 } from "fs";
+var commandModule8 = {
+  command: "worldgen",
+  describe: "Autogenerate interfaces for Systems and World based on existing contracts and the config file",
+  builder(yargs) {
+    return yargs.options({
+      configPath: { type: "string", desc: "Path to the config file" },
+      clean: { type: "boolean", desc: "Clear the worldgen directory before generating new interfaces" }
+    });
+  },
+  async handler(args) {
+    const { configPath, clean } = args;
+    const srcDir = await getSrcDirectory();
+    const existingContracts = glob2.sync(`${srcDir}/**/*.sol`).map((path6) => ({
+      path: path6,
+      basename: basename2(path6, ".sol")
+    }));
+    const worldConfig = await loadWorldConfig(
+      configPath,
+      existingContracts.map(({ basename: basename3 }) => basename3)
+    );
+    const storeConfig = await loadStoreConfig(configPath);
+    const mudConfig = { ...worldConfig, ...storeConfig };
+    if (clean)
+      rmSync3(path4.join(srcDir, worldConfig.worldgenDirectory), { recursive: true, force: true });
+    await worldgen(mudConfig, existingContracts, srcDir);
+    process.exit(0);
+  }
+};
+var worldgen_default = commandModule8;
+
+// src/commands/set-version.ts
+import chalk4 from "chalk";
+import { existsSync, readFileSync as readFileSync3, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "fs";
+import path5 from "path";
+
+// package.json
+var package_default = {
+  name: "@latticexyz/cli",
+  version: "2.0.0-alpha.58+785a3249",
+  description: "Command line interface for mud",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  type: "module",
+  license: "MIT",
+  bin: {
+    mud: "./dist/mud.js",
+    mud2: "./dist/mud2.js"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/latticexyz/mud.git",
+    directory: "packages/cli"
+  },
+  scripts: {
+    prepare: "yarn build && chmod u+x git-install.sh",
+    codegen: "ts-node --esm --files ./scripts/codegen.ts",
+    lint: "eslint . --ext .ts",
+    dev: "tsup --watch",
+    build: "tsup",
+    link: "yarn link",
+    test: "vitest typecheck --run && yarn test:contracts",
+    "test:contracts": "yarn codegen && forge test",
+    "git:install": "bash git-install.sh",
+    release: "npm publish --access=public"
+  },
+  devDependencies: {
+    "@latticexyz/store": "^2.0.0-alpha.58+785a3249",
+    "@types/ejs": "^3.1.1",
+    "@types/glob": "^7.2.0",
+    "@types/node": "^17.0.34",
+    "@types/openurl": "^1.0.0",
+    "@types/yargs": "^17.0.10",
+    esbuild: "^0.15.16",
+    tsup: "^6.6.3",
+    vitest: "^0.29.8"
+  },
+  dependencies: {
+    "@improbable-eng/grpc-web": "^0.15.0",
+    "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
+    "@latticexyz/schema-type": "^2.0.0-alpha.58+785a3249",
+    "@latticexyz/services": "^2.0.0-alpha.58+785a3249",
+    "@latticexyz/solecs": "^2.0.0-alpha.58+785a3249",
+    "@latticexyz/std-contracts": "^2.0.0-alpha.58+785a3249",
+    "@solidity-parser/parser": "^0.16.0",
+    "@typechain/ethers-v5": "^10.1.1",
+    chalk: "^5.0.1",
+    chokidar: "^3.5.3",
+    dotenv: "^16.0.3",
+    "ds-test": "https://github.com/dapphub/ds-test.git#c9ce3f25bde29fc5eb9901842bf02850dfd2d084",
+    ejs: "^3.1.8",
+    esbuild: "^0.17.14",
+    ethers: "^5.7.2",
+    execa: "^7.0.0",
+    "find-up": "^6.3.0",
+    "forge-std": "https://github.com/foundry-rs/forge-std.git#b4f121555729b3afb3c5ffccb62ff4b6e2818fd3",
+    glob: "^8.0.3",
+    "nice-grpc-web": "^2.0.1",
+    openurl: "^1.1.1",
+    path: "^0.12.7",
+    prettier: "^2.8.4",
+    "prettier-plugin-solidity": "^1.1.2",
+    solmate: "https://github.com/Rari-Capital/solmate.git#9cf1428245074e39090dceacb0c28b1f684f584c",
+    table: "^6.8.1",
+    "ts-node": "^10.9.1",
+    typechain: "^8.1.1",
+    typescript: "^4.9.5",
+    yargs: "^17.7.1",
+    zod: "^3.21.4",
+    "zod-validation-error": "^1.0.1"
+  },
+  gitHead: "785a324920c11e24399c5edf575a9099ee4077b6"
+};
+
+// src/commands/set-version.ts
+var BACKUP_FILE = ".mudbackup";
+var MUD_PREFIX = "@latticexyz";
+var commandModule9 = {
+  command: "set-version",
+  describe: "Install a custom MUD version and optionally backup the previously installed version",
+  builder(yargs) {
+    return yargs.options({
+      backup: { type: "boolean", description: `Back up the current MUD versions to "${BACKUP_FILE}"` },
+      force: {
+        type: "boolean",
+        description: `Backup fails if a "${BACKUP_FILE}" file is found, unless --force is provided`
+      },
+      restore: { type: "boolean", description: `Restore the previous MUD versions from "${BACKUP_FILE}"` },
+      mudVersion: { alias: "v", type: "string", description: "The MUD version to install" }
+    });
+  },
+  async handler(options) {
+    try {
+      if (!options.mudVersion && !options.restore) {
+        throw new MUDError(`Version parameter is required unless --restore is provided.`);
+      }
+      options.mudVersion = options.mudVersion === "canary" ? await getCanaryVersion(package_default.name) : options.mudVersion;
+      const rootPath = "./package.json";
+      const { workspaces } = updatePackageJson(rootPath, options);
+      if (workspaces) {
+        for (const workspace of workspaces) {
+          const filePath = path5.join(workspace, "/package.json");
+          updatePackageJson(filePath, options);
+        }
+      }
+    } catch (e) {
+      logError(e);
+    } finally {
+      process.exit(0);
+    }
+  }
+};
+function updatePackageJson(filePath, options) {
+  const { backup, restore, force, mudVersion } = options;
+  const backupFilePath = path5.join(path5.dirname(filePath), BACKUP_FILE);
+  if (backup && !force && existsSync(backupFilePath)) {
+    throw new MUDError(
+      `A backup file already exists at ${backupFilePath}.
+Use --force to overwrite it or --restore to restore it.`
+    );
+  }
+  const packageJson = readPackageJson(filePath);
+  const backupJson = restore ? readPackageJson(backupFilePath) : void 0;
+  const mudDependencies = {};
+  for (const key in packageJson.dependencies) {
+    if (key.startsWith(MUD_PREFIX)) {
+      mudDependencies[key] = packageJson.dependencies[key];
+    }
+  }
+  const mudDevDependencies = {};
+  for (const key in packageJson.devDependencies) {
+    if (key.startsWith(MUD_PREFIX)) {
+      mudDevDependencies[key] = packageJson.devDependencies[key];
+    }
+  }
+  if (backup) {
+    writeFileSync3(
+      backupFilePath,
+      JSON.stringify({ dependencies: mudDependencies, devDependencies: mudDevDependencies }, null, 2)
+    );
+    console.log(chalk4.green(`Backed up MUD dependencies from ${filePath} to ${backupFilePath}`));
+  }
+  for (const key in packageJson.dependencies) {
+    if (key.startsWith(MUD_PREFIX)) {
+      packageJson.dependencies[key] = restore && backupJson ? backupJson.dependencies[key] : mudVersion || packageJson.dependencies[key];
+    }
+  }
+  for (const key in packageJson.devDependencies) {
+    if (key.startsWith(MUD_PREFIX)) {
+      packageJson.devDependencies[key] = restore && backupJson ? backupJson.devDependencies[key] : mudVersion || packageJson.devDependencies[key];
+    }
+  }
+  writeFileSync3(filePath, JSON.stringify(packageJson, null, 2) + "\n");
+  console.log(`Updating ${filePath}`);
+  logComparison(mudDependencies, packageJson.dependencies);
+  logComparison(mudDevDependencies, packageJson.devDependencies);
+  if (restore && !backup) {
+    rmSync4(backupFilePath);
+    console.log(chalk4.green(`Cleaned up ${backupFilePath}`));
+  }
+  return packageJson;
+}
+function readPackageJson(path6) {
+  try {
+    const jsonString = readFileSync3(path6, "utf8");
+    return JSON.parse(jsonString);
+  } catch {
+    throw new MUDError("Could not read JSON at " + path6);
+  }
+}
+async function getCanaryVersion(pkg) {
+  try {
+    console.log(chalk4.blue("fetching MUD canary version..."));
+    const result = await (await fetch(`https://registry.npmjs.org/${pkg}`)).json();
+    const canary = result["dist-tags"].canary;
+    console.log(chalk4.green("MUD canary version:", canary));
+    return canary;
+  } catch (e) {
+    throw new MUDError(`Could not fetch canary version of ${pkg}`);
+  }
+}
+function logComparison(prev, curr) {
+  for (const key in prev) {
+    if (prev[key] !== curr[key]) {
+      console.log(`${key}: ${chalk4.red(prev[key])} -> ${chalk4.green(curr[key])}`);
+    }
+  }
+}
+var set_version_default = commandModule9;
+
+// src/commands/test-v2.ts
+import chalk5 from "chalk";
+import { rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
+var WORLD_ADDRESS_FILE = ".mudtest";
+var commandModule10 = {
+  command: "test-v2",
+  describe: "Run tests in MUD v2 contracts",
+  builder(yargs) {
+    return yargs.options({
+      ...yDeployOptions,
+      port: { type: "number", description: "Port to run internal node for fork testing on", default: 4242 },
+      worldAddress: {
+        type: "string",
+        description: "Address of an existing world contract. If provided, deployment is skipped and the RPC provided in the foundry.toml is used for fork testing."
+      },
+      forgeOptions: { type: "string", description: "Options to pass to forge test" }
+    });
+  },
+  async handler(args) {
+    if (!args.worldAddress) {
+      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(args.port)];
+      anvil(anvilArgs);
+    }
+    const forkRpc = args.worldAddress ? await getRpcUrl(args.profile) : `http://127.0.0.1:${args.port}`;
+    const worldAddress = args.worldAddress ?? (await deployHandler({
+      ...args,
+      saveDeployment: false,
+      rpc: forkRpc
+    })).worldAddress;
+    console.log(chalk5.blue("World address", worldAddress));
+    writeFileSync4(WORLD_ADDRESS_FILE, worldAddress);
+    const userOptions = args.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+    try {
+      const testResult = await forge(["test", "--fork-url", forkRpc, ...userOptions], {
+        profile: args.profile
+      });
+      console.log(testResult);
+    } catch (e) {
+      console.error(e);
+    }
+    rmSync5(WORLD_ADDRESS_FILE);
+    process.exit(0);
+  }
+};
+var test_v2_default = commandModule10;
+
+// src/commands/index.ts
+var commands = [
+  deploy_v2_default,
+  devnode_default,
+  faucet_default,
+  gas_report_default,
+  hello_default,
+  tablegen_default,
+  tsgen_default,
+  worldgen_default,
+  set_version_default,
+  test_v2_default
+];
+
+export {
+  commands
+};
+/*! Bundled license information:
+
+long/index.js:
+  (**
+   * @license
+   * Copyright 2009 The Closure Library Authors
+   * Copyright 2020 Daniel Wirtz / The long.js Authors.
+   *
+   * 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.
+   *
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/