@donezone/cli 0.1.50 → 0.1.55

package/dist/index.js

@@ -9536,20 +9536,20 @@ var require_bn = __commonJS((exports, module) => {
       MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
     }
     inherits(K256, MPrime);
-    K256.prototype.split = function split(input, output2) {
+    K256.prototype.split = function split(input, output) {
       var mask = 4194303;
       var outLen = Math.min(input.length, 9);
       for (var i = 0;i < outLen; i++) {
-        output2.words[i] = input.words[i];
+        output.words[i] = input.words[i];
       }
-      output2.length = outLen;
+      output.length = outLen;
       if (input.length <= 9) {
         input.words[0] = 0;
         input.length = 1;
         return;
       }
       var prev = input.words[9];
-      output2.words[output2.length++] = prev & mask;
+      output.words[output.length++] = prev & mask;
       for (i = 10;i < input.length; i++) {
         var next = input.words[i] | 0;
         input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
@@ -10022,11 +10022,11 @@ var require_utils4 = __commonJS((exports) => {
       return this[key] !== undefined ? this[key] : this[key] = computer.call(this);
     };
   }
-  function parseBytes(bytes2) {
-    return typeof bytes2 === "string" ? utils.toArray(bytes2, "hex") : bytes2;
+  function parseBytes(bytes) {
+    return typeof bytes === "string" ? utils.toArray(bytes, "hex") : bytes;
   }
-  function intFromLE(bytes2) {
-    return new BN(bytes2, "hex", "le");
+  function intFromLE(bytes) {
+    return new BN(bytes, "hex", "le");
   }
   var utils = exports;
   var BN = require_bn();
@@ -10312,18 +10312,18 @@ var require_base = __commonJS((exports, module) => {
   BasePoint.prototype.validate = function validate() {
     return this.curve.validate(this);
   };
-  BaseCurve.prototype.decodePoint = function decodePoint(bytes2, enc) {
-    bytes2 = utils.toArray(bytes2, enc);
+  BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
+    bytes = utils.toArray(bytes, enc);
     var len = this.p.byteLength();
-    if ((bytes2[0] === 4 || bytes2[0] === 6 || bytes2[0] === 7) && bytes2.length - 1 === 2 * len) {
-      if (bytes2[0] === 6)
-        assert(bytes2[bytes2.length - 1] % 2 === 0);
-      else if (bytes2[0] === 7)
-        assert(bytes2[bytes2.length - 1] % 2 === 1);
-      var res = this.point(bytes2.slice(1, 1 + len), bytes2.slice(1 + len, 1 + 2 * len));
+    if ((bytes[0] === 4 || bytes[0] === 6 || bytes[0] === 7) && bytes.length - 1 === 2 * len) {
+      if (bytes[0] === 6)
+        assert(bytes[bytes.length - 1] % 2 === 0);
+      else if (bytes[0] === 7)
+        assert(bytes[bytes.length - 1] % 2 === 1);
+      var res = this.point(bytes.slice(1, 1 + len), bytes.slice(1 + len, 1 + 2 * len));
       return res;
-    } else if ((bytes2[0] === 2 || bytes2[0] === 3) && bytes2.length - 1 === len) {
-      return this.pointFromX(bytes2.slice(1, 1 + len), bytes2[0] === 3);
+    } else if ((bytes[0] === 2 || bytes[0] === 3) && bytes.length - 1 === len) {
+      return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 3);
     }
     throw new Error("Unknown point format");
   };
@@ -11177,8 +11177,8 @@ var require_mont = __commonJS((exports, module) => {
     return y.redSqr().cmp(rhs) === 0;
   };
   inherits(Point, Base.BasePoint);
-  MontCurve.prototype.decodePoint = function decodePoint(bytes2, enc) {
-    return this.point(utils.toArray(bytes2, enc), 1);
+  MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
+    return this.point(utils.toArray(bytes, enc), 1);
   };
   MontCurve.prototype.point = function point(x, z) {
     return new Point(this, x, z);
@@ -11850,8 +11850,8 @@ var require_common = __commonJS((exports) => {
   };
   BlockHash.prototype._pad = function pad() {
     var len = this.pendingTotal;
-    var bytes2 = this._delta8;
-    var k = bytes2 - (len + this.padLength) % bytes2;
+    var bytes = this._delta8;
+    var k = bytes - (len + this.padLength) % bytes;
     var res = new Array(k + this.padLength);
     res[0] = 128;
     for (var i = 1;i < k; i++)
@@ -11998,9 +11998,9 @@ var require_1 = __commonJS((exports, module) => {
 
 // ../../node_modules/hash.js/lib/hash/sha/256.js
 var require_256 = __commonJS((exports, module) => {
-  function SHA2562() {
-    if (!(this instanceof SHA2562))
-      return new SHA2562;
+  function SHA256() {
+    if (!(this instanceof SHA256))
+      return new SHA256;
     BlockHash.call(this);
     this.h = [
       1779033703,
@@ -12095,13 +12095,13 @@ var require_256 = __commonJS((exports, module) => {
     3204031479,
     3329325298
   ];
-  utils.inherits(SHA2562, BlockHash);
-  module.exports = SHA2562;
-  SHA2562.blockSize = 512;
-  SHA2562.outSize = 256;
-  SHA2562.hmacStrength = 192;
-  SHA2562.padLength = 64;
-  SHA2562.prototype._update = function _update(msg, start) {
+  utils.inherits(SHA256, BlockHash);
+  module.exports = SHA256;
+  SHA256.blockSize = 512;
+  SHA256.outSize = 256;
+  SHA256.hmacStrength = 192;
+  SHA256.padLength = 64;
+  SHA256.prototype._update = function _update(msg, start) {
     var W = this.W;
     for (var i = 0;i < 16; i++)
       W[i] = msg[start + i];
@@ -12137,7 +12137,7 @@ var require_256 = __commonJS((exports, module) => {
     this.h[6] = sum32(this.h[6], g);
     this.h[7] = sum32(this.h[7], h);
   };
-  SHA2562.prototype._digest = function digest(enc) {
+  SHA256.prototype._digest = function digest(enc) {
     if (enc === "hex")
       return utils.toHex32(this.h, "big");
     else
@@ -12150,7 +12150,7 @@ var require_224 = __commonJS((exports, module) => {
   function SHA224() {
     if (!(this instanceof SHA224))
       return new SHA224;
-    SHA2562.call(this);
+    SHA256.call(this);
     this.h = [
       3238371032,
       914150663,
@@ -12163,8 +12163,8 @@ var require_224 = __commonJS((exports, module) => {
     ];
   }
   var utils = require_utils5();
-  var SHA2562 = require_256();
-  utils.inherits(SHA224, SHA2562);
+  var SHA256 = require_256();
+  utils.inherits(SHA224, SHA256);
   module.exports = SHA224;
   SHA224.blockSize = 512;
   SHA224.outSize = 224;
@@ -14434,10 +14434,10 @@ var require_ec = __commonJS((exports, module) => {
       entropyEnc: options.entropy && options.entropyEnc || "utf8",
       nonce: this.n.toArray()
     });
-    var bytes2 = this.n.byteLength();
+    var bytes = this.n.byteLength();
     var ns2 = this.n.sub(new BN(2));
     for (;; ) {
-      var priv = new BN(drbg.generate(bytes2));
+      var priv = new BN(drbg.generate(bytes));
       if (priv.cmp(ns2) > 0)
         continue;
       priv.iaddn(1);
@@ -14484,9 +14484,9 @@ var require_ec = __commonJS((exports, module) => {
     key = this.keyFromPrivate(key, enc);
     msg = this._truncateToN(msg, false, options.msgBitLength);
     assert(!msg.isNeg(), "Can not sign a negative message");
-    var bytes2 = this.n.byteLength();
-    var bkey = key.getPrivate().toArray("be", bytes2);
-    var nonce = msg.toArray("be", bytes2);
+    var bytes = this.n.byteLength();
+    var bkey = key.getPrivate().toArray("be", bytes);
+    var nonce = msg.toArray("be", bytes);
     assert(new BN(nonce).eq(msg), "Can not sign message");
     var drbg = new HmacDRBG({
       hash: this.hash,
@@ -14769,19 +14769,19 @@ var require_eddsa = __commonJS((exports, module) => {
     enc[this.encodingLength - 1] |= point.getX().isOdd() ? 128 : 0;
     return enc;
   };
-  EDDSA.prototype.decodePoint = function decodePoint(bytes2) {
-    bytes2 = utils.parseBytes(bytes2);
-    var lastIx = bytes2.length - 1;
-    var normed = bytes2.slice(0, lastIx).concat(bytes2[lastIx] & ~128);
-    var xIsOdd = (bytes2[lastIx] & 128) !== 0;
+  EDDSA.prototype.decodePoint = function decodePoint(bytes) {
+    bytes = utils.parseBytes(bytes);
+    var lastIx = bytes.length - 1;
+    var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~128);
+    var xIsOdd = (bytes[lastIx] & 128) !== 0;
     var y = utils.intFromLE(normed);
     return this.curve.pointFromY(y, xIsOdd);
   };
   EDDSA.prototype.encodeInt = function encodeInt(num) {
     return num.toArray("le", this.encodingLength);
   };
-  EDDSA.prototype.decodeInt = function decodeInt(bytes2) {
-    return utils.intFromLE(bytes2);
+  EDDSA.prototype.decodeInt = function decodeInt(bytes) {
+    return utils.intFromLE(bytes);
   };
   EDDSA.prototype.isPoint = function isPoint(val) {
     return val instanceof this.pointClass;
@@ -14844,9 +14844,9 @@ var require_memory = __commonJS((exports) => {
     get json() {
       return this.read_json();
     }
-    write(bytes2) {
-      this.slice.set(bytes2);
-      this.length = bytes2.length;
+    write(bytes) {
+      this.slice.set(bytes);
+      this.length = bytes.length;
     }
     write_b64(b64) {
       this.write(Buffer.from(b64, "base64"));
@@ -14953,12 +14953,12 @@ var require_base64_js = __commonJS((exports) => {
   }
   function encodeChunk(uint8, start, end) {
     var tmp;
-    var output2 = [];
+    var output = [];
     for (var i2 = start;i2 < end; i2 += 3) {
       tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
-      output2.push(tripletToBase64(tmp));
+      output.push(tripletToBase64(tmp));
     }
-    return output2.join("");
+    return output.join("");
   }
   function fromByteArray(uint8) {
     var tmp;
@@ -15162,13 +15162,13 @@ var require_bech32 = __commonJS((exports, module) => {
     }
     return result;
   }
-  function toWordsUnsafe(bytes2) {
-    var res = convert(bytes2, 8, 5, true);
+  function toWordsUnsafe(bytes) {
+    var res = convert(bytes, 8, 5, true);
     if (Array.isArray(res))
       return res;
   }
-  function toWords(bytes2) {
-    var res = convert(bytes2, 8, 5, true);
+  function toWords(bytes) {
+    var res = convert(bytes, 8, 5, true);
     if (Array.isArray(res))
       return res;
     throw new Error(res);
@@ -15463,8 +15463,8 @@ var require_dist = __commonJS((exports) => {
     }
     return result;
   }
-  function toWords(bytes2) {
-    return convert(bytes2, 8, 5, true);
+  function toWords(bytes) {
+    return convert(bytes, 8, 5, true);
   }
   function fromWordsUnsafe(words) {
     const res = convert(words, 5, 8, false);
@@ -15639,8 +15639,8 @@ var require_backendApi = __commonJS((exports) => {
 
 // ../../node_modules/@terran-one/cosmwasm-vm-js/dist/backend/querier.js
 var require_querier = __commonJS((exports) => {
-  function parseQuery(bytes2) {
-    const query = JSON.parse(new TextDecoder().decode(bytes2));
+  function parseQuery(bytes) {
+    const query = JSON.parse(new TextDecoder().decode(bytes));
     return query;
   }
   function objectToBase64(obj) {
@@ -17157,7 +17157,7 @@ var require_immutable = __commonJS((exports, module) => {
       throw new TypeError("Invalid keyPath: expected Ordered Collection or Array: " + keyPath);
     }
     var toString = Object.prototype.toString;
-    function isPlainObject2(value) {
+    function isPlainObject(value) {
       if (!value || typeof value !== "object" || toString.call(value) !== "[object Object]") {
         return false;
       }
@@ -17174,7 +17174,7 @@ var require_immutable = __commonJS((exports, module) => {
       return parentProto === proto;
     }
     function isDataStructure(value) {
-      return typeof value === "object" && (isImmutable(value) || Array.isArray(value) || isPlainObject2(value));
+      return typeof value === "object" && (isImmutable(value) || Array.isArray(value) || isPlainObject(value));
     }
     function quoteString(value) {
       try {
@@ -17604,21 +17604,21 @@ var require_immutable = __commonJS((exports, module) => {
           break;
         }
       }
-      var exists2 = idx < len;
-      if (exists2 ? entries[idx][1] === value : removed) {
+      var exists = idx < len;
+      if (exists ? entries[idx][1] === value : removed) {
         return this;
       }
       SetRef(didAlter);
-      (removed || !exists2) && SetRef(didChangeSize);
+      (removed || !exists) && SetRef(didChangeSize);
       if (removed && entries.length === 1) {
         return;
       }
-      if (!exists2 && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
+      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
         return createNodes(ownerID, entries, key, value);
       }
       var isEditable = ownerID && ownerID === this.ownerID;
       var newEntries = isEditable ? entries : arrCopy(entries);
-      if (exists2) {
+      if (exists) {
         if (removed) {
           idx === len - 1 ? newEntries.pop() : newEntries[idx] = newEntries.pop();
         } else {
@@ -17653,29 +17653,29 @@ var require_immutable = __commonJS((exports, module) => {
       var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
       var bit = 1 << keyHashFrag;
       var bitmap = this.bitmap;
-      var exists2 = (bitmap & bit) !== 0;
-      if (!exists2 && value === NOT_SET) {
+      var exists = (bitmap & bit) !== 0;
+      if (!exists && value === NOT_SET) {
         return this;
       }
       var idx = popCount(bitmap & bit - 1);
       var nodes = this.nodes;
-      var node = exists2 ? nodes[idx] : undefined;
+      var node = exists ? nodes[idx] : undefined;
       var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);
       if (newNode === node) {
         return this;
       }
-      if (!exists2 && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
+      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
         return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
       }
-      if (exists2 && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {
+      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {
         return nodes[idx ^ 1];
       }
-      if (exists2 && newNode && nodes.length === 1 && isLeafNode(newNode)) {
+      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
         return newNode;
       }
       var isEditable = ownerID && ownerID === this.ownerID;
-      var newBitmap = exists2 ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;
-      var newNodes = exists2 ? newNode ? setAt(nodes, idx, newNode, isEditable) : spliceOut(nodes, idx, isEditable) : spliceIn(nodes, idx, newNode, isEditable);
+      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;
+      var newNodes = exists ? newNode ? setAt(nodes, idx, newNode, isEditable) : spliceOut(nodes, idx, isEditable) : spliceIn(nodes, idx, newNode, isEditable);
       if (isEditable) {
         this.bitmap = newBitmap;
         this.nodes = newNodes;
@@ -17764,18 +17764,18 @@ var require_immutable = __commonJS((exports, module) => {
           break;
         }
       }
-      var exists2 = idx < len;
-      if (exists2 ? entries[idx][1] === value : removed) {
+      var exists = idx < len;
+      if (exists ? entries[idx][1] === value : removed) {
         return this;
       }
       SetRef(didAlter);
-      (removed || !exists2) && SetRef(didChangeSize);
+      (removed || !exists) && SetRef(didChangeSize);
       if (removed && len === 2) {
         return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
       }
       var isEditable = ownerID && ownerID === this.ownerID;
       var newEntries = isEditable ? entries : arrCopy(entries);
-      if (exists2) {
+      if (exists) {
         if (removed) {
           idx === len - 1 ? newEntries.pop() : newEntries[idx] = newEntries.pop();
         } else {
@@ -20095,7 +20095,7 @@ var require_immutable = __commonJS((exports, module) => {
       return fromJSWith([], converter || defaultConverter, value, "", converter && converter.length > 2 ? [] : undefined, { "": value });
     }
     function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
-      if (typeof value !== "string" && !isImmutable(value) && (isArrayLike(value) || hasIterator(value) || isPlainObject2(value))) {
+      if (typeof value !== "string" && !isImmutable(value) && (isArrayLike(value) || hasIterator(value) || isPlainObject(value))) {
         if (~stack.indexOf(value)) {
           throw new TypeError("Cannot convert circular structure to Immutable");
         }
@@ -20139,7 +20139,7 @@ var require_immutable = __commonJS((exports, module) => {
       isAssociative,
       isOrdered,
       isValueObject,
-      isPlainObject: isPlainObject2,
+      isPlainObject,
       isSeq,
       isList,
       isMap,
@@ -20195,7 +20195,7 @@ var require_immutable = __commonJS((exports, module) => {
     exports2.isOrdered = isOrdered;
     exports2.isOrderedMap = isOrderedMap;
     exports2.isOrderedSet = isOrderedSet;
-    exports2.isPlainObject = isPlainObject2;
+    exports2.isPlainObject = isPlainObject;
     exports2.isRecord = isRecord;
     exports2.isSeq = isSeq;
     exports2.isSet = isSet;
@@ -20436,11 +20436,11 @@ var require_lib = __commonJS((exports, module) => {
   function isCompressed(value) {
     assert(toTypeString(value) === "Boolean", "Expected compressed to be a Boolean");
   }
-  function getAssertedOutput(output2 = (len) => new Uint8Array(len), length) {
-    if (typeof output2 === "function")
-      output2 = output2(length);
-    isUint8Array("output", output2, length);
-    return output2;
+  function getAssertedOutput(output = (len) => new Uint8Array(len), length) {
+    if (typeof output === "function")
+      output = output(length);
+    isUint8Array("output", output, length);
+    return output;
   }
   function toTypeString(value) {
     return Object.prototype.toString.call(value).slice(8, -1);
@@ -20507,39 +20507,39 @@ var require_lib = __commonJS((exports, module) => {
         isUint8Array("public key", pubkey, [33, 65]);
         return secp256k1.publicKeyVerify(pubkey) === 0;
       },
-      publicKeyCreate(seckey, compressed = true, output2) {
+      publicKeyCreate(seckey, compressed = true, output) {
         isUint8Array("private key", seckey, 32);
         isCompressed(compressed);
-        output2 = getAssertedOutput(output2, compressed ? 33 : 65);
-        switch (secp256k1.publicKeyCreate(output2, seckey)) {
+        output = getAssertedOutput(output, compressed ? 33 : 65);
+        switch (secp256k1.publicKeyCreate(output, seckey)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.SECKEY_INVALID);
           case 2:
             throw new Error(errors.PUBKEY_SERIALIZE);
         }
       },
-      publicKeyConvert(pubkey, compressed = true, output2) {
+      publicKeyConvert(pubkey, compressed = true, output) {
         isUint8Array("public key", pubkey, [33, 65]);
         isCompressed(compressed);
-        output2 = getAssertedOutput(output2, compressed ? 33 : 65);
-        switch (secp256k1.publicKeyConvert(output2, pubkey)) {
+        output = getAssertedOutput(output, compressed ? 33 : 65);
+        switch (secp256k1.publicKeyConvert(output, pubkey)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.PUBKEY_PARSE);
           case 2:
             throw new Error(errors.PUBKEY_SERIALIZE);
         }
       },
-      publicKeyNegate(pubkey, compressed = true, output2) {
+      publicKeyNegate(pubkey, compressed = true, output) {
         isUint8Array("public key", pubkey, [33, 65]);
         isCompressed(compressed);
-        output2 = getAssertedOutput(output2, compressed ? 33 : 65);
-        switch (secp256k1.publicKeyNegate(output2, pubkey)) {
+        output = getAssertedOutput(output, compressed ? 33 : 65);
+        switch (secp256k1.publicKeyNegate(output, pubkey)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.PUBKEY_PARSE);
           case 2:
@@ -20548,17 +20548,17 @@ var require_lib = __commonJS((exports, module) => {
             throw new Error(errors.PUBKEY_SERIALIZE);
         }
       },
-      publicKeyCombine(pubkeys, compressed = true, output2) {
+      publicKeyCombine(pubkeys, compressed = true, output) {
         assert(Array.isArray(pubkeys), "Expected public keys to be an Array");
         assert(pubkeys.length > 0, "Expected public keys array will have more than zero items");
         for (const pubkey of pubkeys) {
           isUint8Array("public key", pubkey, [33, 65]);
         }
         isCompressed(compressed);
-        output2 = getAssertedOutput(output2, compressed ? 33 : 65);
-        switch (secp256k1.publicKeyCombine(output2, pubkeys)) {
+        output = getAssertedOutput(output, compressed ? 33 : 65);
+        switch (secp256k1.publicKeyCombine(output, pubkeys)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.PUBKEY_PARSE);
           case 2:
@@ -20567,28 +20567,28 @@ var require_lib = __commonJS((exports, module) => {
             throw new Error(errors.PUBKEY_SERIALIZE);
         }
       },
-      publicKeyTweakAdd(pubkey, tweak, compressed = true, output2) {
+      publicKeyTweakAdd(pubkey, tweak, compressed = true, output) {
         isUint8Array("public key", pubkey, [33, 65]);
         isUint8Array("tweak", tweak, 32);
         isCompressed(compressed);
-        output2 = getAssertedOutput(output2, compressed ? 33 : 65);
-        switch (secp256k1.publicKeyTweakAdd(output2, pubkey, tweak)) {
+        output = getAssertedOutput(output, compressed ? 33 : 65);
+        switch (secp256k1.publicKeyTweakAdd(output, pubkey, tweak)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.PUBKEY_PARSE);
           case 2:
             throw new Error(errors.TWEAK_ADD);
         }
       },
-      publicKeyTweakMul(pubkey, tweak, compressed = true, output2) {
+      publicKeyTweakMul(pubkey, tweak, compressed = true, output) {
         isUint8Array("public key", pubkey, [33, 65]);
         isUint8Array("tweak", tweak, 32);
         isCompressed(compressed);
-        output2 = getAssertedOutput(output2, compressed ? 33 : 65);
-        switch (secp256k1.publicKeyTweakMul(output2, pubkey, tweak)) {
+        output = getAssertedOutput(output, compressed ? 33 : 65);
+        switch (secp256k1.publicKeyTweakMul(output, pubkey, tweak)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.PUBKEY_PARSE);
           case 2:
@@ -20604,32 +20604,32 @@ var require_lib = __commonJS((exports, module) => {
             throw new Error(errors.SIG_PARSE);
         }
       },
-      signatureExport(sig, output2) {
+      signatureExport(sig, output) {
         isUint8Array("signature", sig, 64);
-        output2 = getAssertedOutput(output2, 72);
-        const obj = { output: output2, outputlen: 72 };
+        output = getAssertedOutput(output, 72);
+        const obj = { output, outputlen: 72 };
         switch (secp256k1.signatureExport(obj, sig)) {
           case 0:
-            return output2.slice(0, obj.outputlen);
+            return output.slice(0, obj.outputlen);
           case 1:
             throw new Error(errors.SIG_PARSE);
           case 2:
             throw new Error(errors.IMPOSSIBLE_CASE);
         }
       },
-      signatureImport(sig, output2) {
+      signatureImport(sig, output) {
         isUint8Array("signature", sig);
-        output2 = getAssertedOutput(output2, 64);
-        switch (secp256k1.signatureImport(output2, sig)) {
+        output = getAssertedOutput(output, 64);
+        switch (secp256k1.signatureImport(output, sig)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.SIG_PARSE);
           case 2:
             throw new Error(errors.IMPOSSIBLE_CASE);
         }
       },
-      ecdsaSign(msg32, seckey, options = {}, output2) {
+      ecdsaSign(msg32, seckey, options = {}, output) {
         isUint8Array("message", msg32, 32);
         isUint8Array("private key", seckey, 32);
         assert(toTypeString(options) === "Object", "Expected options to be an Object");
@@ -20637,8 +20637,8 @@ var require_lib = __commonJS((exports, module) => {
           isUint8Array("options.data", options.data);
         if (options.noncefn !== undefined)
           assert(toTypeString(options.noncefn) === "Function", "Expected options.noncefn to be a Function");
-        output2 = getAssertedOutput(output2, 64);
-        const obj = { signature: output2, recid: null };
+        output = getAssertedOutput(output, 64);
+        const obj = { signature: output, recid: null };
         switch (secp256k1.ecdsaSign(obj, msg32, seckey, options.data, options.noncefn)) {
           case 0:
             return obj;
@@ -20663,15 +20663,15 @@ var require_lib = __commonJS((exports, module) => {
             throw new Error(errors.PUBKEY_PARSE);
         }
       },
-      ecdsaRecover(sig, recid, msg32, compressed = true, output2) {
+      ecdsaRecover(sig, recid, msg32, compressed = true, output) {
         isUint8Array("signature", sig, 64);
         assert(toTypeString(recid) === "Number" && recid >= 0 && recid <= 3, "Expected recovery id to be a Number within interval [0, 3]");
         isUint8Array("message", msg32, 32);
         isCompressed(compressed);
-        output2 = getAssertedOutput(output2, compressed ? 33 : 65);
-        switch (secp256k1.ecdsaRecover(output2, sig, recid, msg32)) {
+        output = getAssertedOutput(output, compressed ? 33 : 65);
+        switch (secp256k1.ecdsaRecover(output, sig, recid, msg32)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.SIG_PARSE);
           case 2:
@@ -20680,7 +20680,7 @@ var require_lib = __commonJS((exports, module) => {
             throw new Error(errors.IMPOSSIBLE_CASE);
         }
       },
-      ecdh(pubkey, seckey, options = {}, output2) {
+      ecdh(pubkey, seckey, options = {}, output) {
         isUint8Array("public key", pubkey, [33, 65]);
         isUint8Array("private key", seckey, 32);
         assert(toTypeString(options) === "Object", "Expected options to be an Object");
@@ -20692,13 +20692,13 @@ var require_lib = __commonJS((exports, module) => {
             isUint8Array("options.xbuf", options.xbuf, 32);
           if (options.ybuf !== undefined)
             isUint8Array("options.ybuf", options.ybuf, 32);
-          isUint8Array("output", output2);
+          isUint8Array("output", output);
         } else {
-          output2 = getAssertedOutput(output2, 32);
+          output = getAssertedOutput(output, 32);
         }
-        switch (secp256k1.ecdh(output2, pubkey, seckey, options.data, options.hashfn, options.xbuf, options.ybuf)) {
+        switch (secp256k1.ecdh(output, pubkey, seckey, options.data, options.hashfn, options.xbuf, options.ybuf)) {
           case 0:
-            return output2;
+            return output;
           case 1:
             throw new Error(errors.PUBKEY_PARSE);
           case 2:
@@ -20763,10 +20763,10 @@ var require_elliptic2 = __commonJS((exports, module) => {
         return null;
     }
   }
-  function savePublicKey(output2, point) {
-    const pubkey = point.encode(null, output2.length === 33);
-    for (let i = 0;i < output2.length; ++i)
-      output2[i] = pubkey[i];
+  function savePublicKey(output, point) {
+    const pubkey = point.encode(null, output.length === 33);
+    for (let i = 0;i < output.length; ++i)
+      output[i] = pubkey[i];
   }
   var EC = require_elliptic().ec;
   var ec = new EC("secp256k1");
@@ -20814,32 +20814,32 @@ var require_elliptic2 = __commonJS((exports, module) => {
       const pair = loadPublicKey(pubkey);
       return pair === null ? 1 : 0;
     },
-    publicKeyCreate(output2, seckey) {
+    publicKeyCreate(output, seckey) {
       const bn = new BN(seckey);
       if (bn.cmp(ecparams.n) >= 0 || bn.isZero())
         return 1;
       const point = ec.keyFromPrivate(seckey).getPublic();
-      savePublicKey(output2, point);
+      savePublicKey(output, point);
       return 0;
     },
-    publicKeyConvert(output2, pubkey) {
+    publicKeyConvert(output, pubkey) {
       const pair = loadPublicKey(pubkey);
       if (pair === null)
         return 1;
       const point = pair.getPublic();
-      savePublicKey(output2, point);
+      savePublicKey(output, point);
       return 0;
     },
-    publicKeyNegate(output2, pubkey) {
+    publicKeyNegate(output, pubkey) {
       const pair = loadPublicKey(pubkey);
       if (pair === null)
         return 1;
       const point = pair.getPublic();
       point.y = point.y.redNeg();
-      savePublicKey(output2, point);
+      savePublicKey(output, point);
       return 0;
     },
-    publicKeyCombine(output2, pubkeys) {
+    publicKeyCombine(output, pubkeys) {
       const pairs = new Array(pubkeys.length);
       for (let i = 0;i < pubkeys.length; ++i) {
         pairs[i] = loadPublicKey(pubkeys[i]);
@@ -20851,10 +20851,10 @@ var require_elliptic2 = __commonJS((exports, module) => {
         point = point.add(pairs[i].pub);
       if (point.isInfinity())
         return 2;
-      savePublicKey(output2, point);
+      savePublicKey(output, point);
       return 0;
     },
-    publicKeyTweakAdd(output2, pubkey, tweak) {
+    publicKeyTweakAdd(output, pubkey, tweak) {
       const pair = loadPublicKey(pubkey);
       if (pair === null)
         return 1;
@@ -20864,10 +20864,10 @@ var require_elliptic2 = __commonJS((exports, module) => {
       const point = pair.getPublic().add(ecparams.g.mul(tweak));
       if (point.isInfinity())
         return 2;
-      savePublicKey(output2, point);
+      savePublicKey(output, point);
       return 0;
     },
-    publicKeyTweakMul(output2, pubkey, tweak) {
+    publicKeyTweakMul(output, pubkey, tweak) {
       const pair = loadPublicKey(pubkey);
       if (pair === null)
         return 1;
@@ -20875,7 +20875,7 @@ var require_elliptic2 = __commonJS((exports, module) => {
       if (tweak.cmp(ecparams.n) >= 0 || tweak.isZero())
         return 2;
       const point = pair.getPublic().mul(tweak);
-      savePublicKey(output2, point);
+      savePublicKey(output, point);
       return 0;
     },
     signatureNormalize(sig) {
@@ -20895,8 +20895,8 @@ var require_elliptic2 = __commonJS((exports, module) => {
         return 1;
       if (new BN(sigS).cmp(ecparams.n) >= 0)
         return 1;
-      const { output: output2 } = obj;
-      let r = output2.subarray(4, 4 + 33);
+      const { output } = obj;
+      let r = output.subarray(4, 4 + 33);
       r[0] = 0;
       r.set(sigR, 1);
       let lenR = 33;
@@ -20908,7 +20908,7 @@ var require_elliptic2 = __commonJS((exports, module) => {
         return 1;
       if (lenR > 1 && r[0] === 0 && !(r[1] & 128))
         return 1;
-      let s = output2.subarray(6 + 33, 6 + 33 + 33);
+      let s = output.subarray(6 + 33, 6 + 33 + 33);
       s[0] = 0;
       s.set(sigS, 1);
       let lenS = 33;
@@ -20921,17 +20921,17 @@ var require_elliptic2 = __commonJS((exports, module) => {
       if (lenS > 1 && s[0] === 0 && !(s[1] & 128))
         return 1;
       obj.outputlen = 6 + lenR + lenS;
-      output2[0] = 48;
-      output2[1] = obj.outputlen - 2;
-      output2[2] = 2;
-      output2[3] = r.length;
-      output2.set(r, 4);
-      output2[4 + lenR] = 2;
-      output2[5 + lenR] = s.length;
-      output2.set(s, 6 + lenR);
+      output[0] = 48;
+      output[1] = obj.outputlen - 2;
+      output[2] = 2;
+      output[3] = r.length;
+      output.set(r, 4);
+      output[4 + lenR] = 2;
+      output[5 + lenR] = s.length;
+      output.set(s, 6 + lenR);
       return 0;
     },
-    signatureImport(output2, sig) {
+    signatureImport(output, sig) {
       if (sig.length < 8)
         return 1;
       if (sig.length > 72)
@@ -20978,8 +20978,8 @@ var require_elliptic2 = __commonJS((exports, module) => {
       let s = new BN(sig.subarray(6 + lenR));
       if (s.cmp(ecparams.n) >= 0)
         s = new BN(0);
-      output2.set(r.toArrayLike(Uint8Array, "be", 32), 0);
-      output2.set(s.toArrayLike(Uint8Array, "be", 32), 32);
+      output.set(r.toArrayLike(Uint8Array, "be", 32), 0);
+      output.set(s.toArrayLike(Uint8Array, "be", 32), 32);
       return 0;
     },
     ecdsaSign(obj, message, seckey, data, noncefn) {
@@ -21022,7 +21022,7 @@ var require_elliptic2 = __commonJS((exports, module) => {
       const isValid = ec.verify(msg32, sigObj, point);
       return isValid ? 0 : 3;
     },
-    ecdsaRecover(output2, sig, recid, msg32) {
+    ecdsaRecover(output, sig, recid, msg32) {
       const sigObj = { r: sig.slice(0, 32), s: sig.slice(32, 64) };
       const sigr = new BN(sigObj.r);
       const sigs = new BN(sigObj.s);
@@ -21036,10 +21036,10 @@ var require_elliptic2 = __commonJS((exports, module) => {
       } catch (err) {
         return 2;
       }
-      savePublicKey(output2, point);
+      savePublicKey(output, point);
       return 0;
     },
-    ecdh(output2, pubkey, seckey, data, hashfn, xbuf, ybuf) {
+    ecdh(output, pubkey, seckey, data, hashfn, xbuf, ybuf) {
       const pair = loadPublicKey(pubkey);
       if (pair === null)
         return 1;
@@ -21049,9 +21049,9 @@ var require_elliptic2 = __commonJS((exports, module) => {
       const point = pair.getPublic().mul(scalar);
       if (hashfn === undefined) {
         const data2 = point.encode(null, true);
-        const sha2562 = ec.hash().update(data2).digest();
+        const sha256 = ec.hash().update(data2).digest();
         for (let i = 0;i < 32; ++i)
-          output2[i] = sha2562[i];
+          output[i] = sha256[i];
       } else {
         if (!xbuf)
           xbuf = new Uint8Array(32);
@@ -21064,10 +21064,10 @@ var require_elliptic2 = __commonJS((exports, module) => {
         for (let i = 0;i < 32; ++i)
           ybuf[i] = y[i];
         const hash = hashfn(xbuf, ybuf, data);
-        const isValid = hash instanceof Uint8Array && hash.length === output2.length;
+        const isValid = hash instanceof Uint8Array && hash.length === output.length;
         if (!isValid)
           return 2;
-        output2.set(hash);
+        output.set(hash);
       }
       return 0;
     }
@@ -21197,19 +21197,19 @@ var require_instance = __commonJS((exports) => {
       let { deallocate } = this.exports;
       deallocate(region.ptr);
     }
-    allocate_bytes(bytes2) {
-      let region = this.allocate(bytes2.length);
-      region.write(bytes2);
+    allocate_bytes(bytes) {
+      let region = this.allocate(bytes.length);
+      region.write(bytes);
       return region;
     }
     allocate_b64(b64) {
-      let bytes2 = Buffer.from(b64, "base64");
-      return this.allocate_bytes(bytes2);
+      let bytes = Buffer.from(b64, "base64");
+      return this.allocate_bytes(bytes);
     }
     allocate_str(str) {
-      const bytes2 = new TextEncoder().encode(str);
-      let region = this.allocate(bytes2.length);
-      region.write(bytes2);
+      const bytes = new TextEncoder().encode(str);
+      let region = this.allocate(bytes.length);
+      region.write(bytes);
       return region;
     }
     allocate_json(obj) {
@@ -21883,13 +21883,13 @@ var require_bech323 = __commonJS((exports, module) => {
     }
     return result;
   }
-  function toWordsUnsafe(bytes2) {
-    var res = convert(bytes2, 8, 5, true);
+  function toWordsUnsafe(bytes) {
+    var res = convert(bytes, 8, 5, true);
     if (Array.isArray(res))
       return res;
   }
-  function toWords(bytes2) {
-    var res = convert(bytes2, 8, 5, true);
+  function toWords(bytes) {
+    var res = convert(bytes, 8, 5, true);
     if (Array.isArray(res))
       return res;
     throw new Error(res);
@@ -22589,23 +22589,23 @@ function utf8Decoder() {
     return;
   return _utf8Decoder !== null && _utf8Decoder !== undefined ? _utf8Decoder : _utf8Decoder = new globalThis.TextDecoder("utf-8");
 }
-function textDecode(bytes2, encoding = "utf-8") {
+function textDecode(bytes, encoding = "utf-8") {
   switch (encoding.toLowerCase()) {
     case "utf-8":
     case "utf8": {
       const dec = utf8Decoder();
-      return dec ? dec.decode(bytes2) : decodeUTF8(bytes2);
+      return dec ? dec.decode(bytes) : decodeUTF8(bytes);
     }
     case "utf-16le":
-      return decodeUTF16LE(bytes2);
+      return decodeUTF16LE(bytes);
     case "us-ascii":
     case "ascii":
-      return decodeASCII(bytes2);
+      return decodeASCII(bytes);
     case "latin1":
     case "iso-8859-1":
-      return decodeLatin1(bytes2);
+      return decodeLatin1(bytes);
     case "windows-1252":
-      return decodeWindows1252(bytes2);
+      return decodeWindows1252(bytes);
     default:
       throw new RangeError(`Encoding '${encoding}' not supported`);
   }
@@ -22630,15 +22630,15 @@ function pushCodePoint(parts, chunk, cp) {
   pushCodeUnit(parts, chunk, 55296 + (cp >> 10));
   pushCodeUnit(parts, chunk, 56320 + (cp & 1023));
 }
-function decodeUTF8(bytes2) {
+function decodeUTF8(bytes) {
   const parts = [];
   const chunk = [];
   let i = 0;
-  if (bytes2.length >= 3 && bytes2[0] === 239 && bytes2[1] === 187 && bytes2[2] === 191) {
+  if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
     i = 3;
   }
-  while (i < bytes2.length) {
-    const b1 = bytes2[i];
+  while (i < bytes.length) {
+    const b1 = bytes[i];
     if (b1 <= 127) {
       pushCodeUnit(parts, chunk, b1);
       i++;
@@ -22650,12 +22650,12 @@ function decodeUTF8(bytes2) {
       continue;
     }
     if (b1 <= 223) {
-      if (i + 1 >= bytes2.length) {
+      if (i + 1 >= bytes.length) {
         pushCodeUnit(parts, chunk, REPLACEMENT);
         i++;
         continue;
       }
-      const b22 = bytes2[i + 1];
+      const b22 = bytes[i + 1];
       if ((b22 & 192) !== 128) {
         pushCodeUnit(parts, chunk, REPLACEMENT);
         i++;
@@ -22667,13 +22667,13 @@ function decodeUTF8(bytes2) {
       continue;
     }
     if (b1 <= 239) {
-      if (i + 2 >= bytes2.length) {
+      if (i + 2 >= bytes.length) {
         pushCodeUnit(parts, chunk, REPLACEMENT);
         i++;
         continue;
       }
-      const b22 = bytes2[i + 1];
-      const b32 = bytes2[i + 2];
+      const b22 = bytes[i + 1];
+      const b32 = bytes[i + 2];
       const valid2 = (b22 & 192) === 128 && (b32 & 192) === 128 && !(b1 === 224 && b22 < 160) && !(b1 === 237 && b22 >= 160);
       if (!valid2) {
         pushCodeUnit(parts, chunk, REPLACEMENT);
@@ -22685,14 +22685,14 @@ function decodeUTF8(bytes2) {
       i += 3;
       continue;
     }
-    if (i + 3 >= bytes2.length) {
+    if (i + 3 >= bytes.length) {
       pushCodeUnit(parts, chunk, REPLACEMENT);
       i++;
       continue;
     }
-    const b2 = bytes2[i + 1];
-    const b3 = bytes2[i + 2];
-    const b4 = bytes2[i + 3];
+    const b2 = bytes[i + 1];
+    const b3 = bytes[i + 2];
+    const b4 = bytes[i + 3];
     const valid = (b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128 && !(b1 === 240 && b2 < 144) && !(b1 === 244 && b2 > 143);
     if (!valid) {
       pushCodeUnit(parts, chunk, REPLACEMENT);
@@ -22706,17 +22706,17 @@ function decodeUTF8(bytes2) {
   flushChunk(parts, chunk);
   return parts.join("");
 }
-function decodeUTF16LE(bytes2) {
+function decodeUTF16LE(bytes) {
   const parts = [];
   const chunk = [];
-  const len = bytes2.length;
+  const len = bytes.length;
   let i = 0;
   while (i + 1 < len) {
-    const u1 = bytes2[i] | bytes2[i + 1] << 8;
+    const u1 = bytes[i] | bytes[i + 1] << 8;
     i += 2;
     if (u1 >= 55296 && u1 <= 56319) {
       if (i + 1 < len) {
-        const u2 = bytes2[i] | bytes2[i + 1] << 8;
+        const u2 = bytes[i] | bytes[i + 1] << 8;
         if (u2 >= 56320 && u2 <= 57343) {
           pushCodeUnit(parts, chunk, u1);
           pushCodeUnit(parts, chunk, u2);
@@ -22741,35 +22741,35 @@ function decodeUTF16LE(bytes2) {
   flushChunk(parts, chunk);
   return parts.join("");
 }
-function decodeASCII(bytes2) {
+function decodeASCII(bytes) {
   const parts = [];
-  for (let i = 0;i < bytes2.length; i += CHUNK) {
-    const end = Math.min(bytes2.length, i + CHUNK);
+  for (let i = 0;i < bytes.length; i += CHUNK) {
+    const end = Math.min(bytes.length, i + CHUNK);
     const codes = new Array(end - i);
     for (let j = i, k = 0;j < end; j++, k++) {
-      codes[k] = bytes2[j] & 127;
+      codes[k] = bytes[j] & 127;
     }
     parts.push(String.fromCharCode.apply(null, codes));
   }
   return parts.join("");
 }
-function decodeLatin1(bytes2) {
+function decodeLatin1(bytes) {
   const parts = [];
-  for (let i = 0;i < bytes2.length; i += CHUNK) {
-    const end = Math.min(bytes2.length, i + CHUNK);
+  for (let i = 0;i < bytes.length; i += CHUNK) {
+    const end = Math.min(bytes.length, i + CHUNK);
     const codes = new Array(end - i);
     for (let j = i, k = 0;j < end; j++, k++) {
-      codes[k] = bytes2[j];
+      codes[k] = bytes[j];
     }
     parts.push(String.fromCharCode.apply(null, codes));
   }
   return parts.join("");
 }
-function decodeWindows1252(bytes2) {
+function decodeWindows1252(bytes) {
   const parts = [];
   let out = "";
-  for (let i = 0;i < bytes2.length; i++) {
-    const b = bytes2[i];
+  for (let i = 0;i < bytes.length; i++) {
+    const b = bytes[i];
     const extra = b >= 128 && b <= 159 ? WINDOWS_1252_EXTRA[b] : undefined;
     out += extra !== null && extra !== undefined ? extra : String.fromCharCode(b);
     if (out.length >= CHUNK) {
@@ -22830,8 +22830,8 @@ class StringType2 {
     this.encoding = encoding;
   }
   get(data, offset = 0) {
-    const bytes2 = data.subarray(offset, offset + this.len);
-    return textDecode(bytes2, this.encoding);
+    const bytes = data.subarray(offset, offset + this.len);
+    return textDecode(bytes, this.encoding);
   }
 }
 var UINT8, UINT16_LE, UINT16_BE, UINT32_LE, UINT32_BE, INT32_BE, UINT64_LE;
@@ -24361,9 +24361,9 @@ class ZipHandler {
       }
     });
     const ds = new DecompressionStream("deflate-raw");
-    const output2 = input.pipeThrough(ds);
+    const output = input.pipeThrough(ds);
     try {
-      const response = new Response(output2);
+      const response = new Response(output);
       const buffer = await response.arrayBuffer();
       return new Uint8Array(buffer);
     } catch (err) {
@@ -24490,20 +24490,20 @@ var init_uint8array_extras = __esm(() => {
 // ../../node_modules/file-type/source/tokens.js
 function stringToBytes(string, encoding) {
   if (encoding === "utf-16le") {
-    const bytes2 = [];
+    const bytes = [];
     for (let index = 0;index < string.length; index++) {
       const code = string.charCodeAt(index);
-      bytes2.push(code & 255, code >> 8 & 255);
+      bytes.push(code & 255, code >> 8 & 255);
     }
-    return bytes2;
+    return bytes;
   }
   if (encoding === "utf-16be") {
-    const bytes2 = [];
+    const bytes = [];
     for (let index = 0;index < string.length; index++) {
       const code = string.charCodeAt(index);
-      bytes2.push(code >> 8 & 255, code & 255);
+      bytes.push(code >> 8 & 255, code & 255);
     }
-    return bytes2;
+    return bytes;
   }
   return [...string].map((character) => character.charCodeAt(0));
 }
@@ -24957,8 +24957,8 @@ async function decompressDeflateRawWithLimit(data, { maximumLength = maximumZipE
       controller.close();
     }
   });
-  const output2 = input.pipeThrough(new DecompressionStream("deflate-raw"));
-  const reader = output2.getReader();
+  const output = input.pipeThrough(new DecompressionStream("deflate-raw"));
+  const reader = output.getReader();
   const chunks = [];
   let totalLength = 0;
   try {
@@ -27511,316 +27511,7 @@ var {
   Help
 } = import__.default;
 
-// ../../node_modules/@noble/hashes/esm/_assert.js
-function bytes(b, ...lengths) {
-  if (!(b instanceof Uint8Array))
-    throw new Error("Expected Uint8Array");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-}
-function exists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function output(out, instance) {
-  bytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-  }
-}
-
-// ../../node_modules/@noble/hashes/esm/utils.js
-function utf8ToBytes(str) {
-  if (typeof str !== "string")
-    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes(data);
-  if (!u8a(data))
-    throw new Error(`expected Uint8Array, got ${typeof data}`);
-  return data;
-}
-function wrapConstructor(hashCons) {
-  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-  const tmp = hashCons();
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = () => hashCons();
-  return hashC;
-}
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-var u8a = (a) => a instanceof Uint8Array;
-var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-var rotr = (word, shift) => word << 32 - shift | word >>> shift;
-var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-if (!isLE)
-  throw new Error("Non little-endian hardware is not supported");
-class Hash {
-  clone() {
-    return this._cloneInto();
-  }
-}
-var toStr = {}.toString;
-
-// ../../node_modules/@noble/hashes/esm/_sha2.js
-function setBigUint64(view, byteOffset, value, isLE2) {
-  if (typeof view.setBigUint64 === "function")
-    return view.setBigUint64(byteOffset, value, isLE2);
-  const _32n = BigInt(32);
-  const _u32_max = BigInt(4294967295);
-  const wh = Number(value >> _32n & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h = isLE2 ? 4 : 0;
-  const l = isLE2 ? 0 : 4;
-  view.setUint32(byteOffset + h, wh, isLE2);
-  view.setUint32(byteOffset + l, wl, isLE2);
-}
-
-class SHA2 extends Hash {
-  constructor(blockLen, outputLen, padOffset, isLE2) {
-    super();
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.padOffset = padOffset;
-    this.isLE = isLE2;
-    this.finished = false;
-    this.length = 0;
-    this.pos = 0;
-    this.destroyed = false;
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
-  }
-  update(data) {
-    exists(this);
-    const { view, buffer, blockLen } = this;
-    data = toBytes(data);
-    const len = data.length;
-    for (let pos = 0;pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      if (take === blockLen) {
-        const dataView = createView(data);
-        for (;blockLen <= len - pos; pos += blockLen)
-          this.process(dataView, pos);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(view, 0);
-        this.pos = 0;
-      }
-    }
-    this.length += data.length;
-    this.roundClean();
-    return this;
-  }
-  digestInto(out) {
-    exists(this);
-    output(out, this);
-    this.finished = true;
-    const { buffer, view, blockLen, isLE: isLE2 } = this;
-    let { pos } = this;
-    buffer[pos++] = 128;
-    this.buffer.subarray(pos).fill(0);
-    if (this.padOffset > blockLen - pos) {
-      this.process(view, 0);
-      pos = 0;
-    }
-    for (let i = pos;i < blockLen; i++)
-      buffer[i] = 0;
-    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
-    this.process(view, 0);
-    const oview = createView(out);
-    const len = this.outputLen;
-    if (len % 4)
-      throw new Error("_sha2: outputLen should be aligned to 32bit");
-    const outLen = len / 4;
-    const state = this.get();
-    if (outLen > state.length)
-      throw new Error("_sha2: outputLen bigger than state");
-    for (let i = 0;i < outLen; i++)
-      oview.setUint32(4 * i, state[i], isLE2);
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to) {
-    to || (to = new this.constructor);
-    to.set(...this.get());
-    const { blockLen, buffer, length, finished, destroyed, pos } = this;
-    to.length = length;
-    to.pos = pos;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    if (length % blockLen)
-      to.buffer.set(buffer);
-    return to;
-  }
-}
-
-// ../../node_modules/@noble/hashes/esm/sha256.js
-var Chi = (a, b, c) => a & b ^ ~a & c;
-var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
-var SHA256_K = /* @__PURE__ */ new Uint32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-var IV = /* @__PURE__ */ new Uint32Array([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-
-class SHA256 extends SHA2 {
-  constructor() {
-    super(64, 32, 8, false);
-    this.A = IV[0] | 0;
-    this.B = IV[1] | 0;
-    this.C = IV[2] | 0;
-    this.D = IV[3] | 0;
-    this.E = IV[4] | 0;
-    this.F = IV[5] | 0;
-    this.G = IV[6] | 0;
-    this.H = IV[7] | 0;
-  }
-  get() {
-    const { A, B, C, D, E, F, G, H } = this;
-    return [A, B, C, D, E, F, G, H];
-  }
-  set(A, B, C, D, E, F, G, H) {
-    this.A = A | 0;
-    this.B = B | 0;
-    this.C = C | 0;
-    this.D = D | 0;
-    this.E = E | 0;
-    this.F = F | 0;
-    this.G = G | 0;
-    this.H = H | 0;
-  }
-  process(view, offset) {
-    for (let i = 0;i < 16; i++, offset += 4)
-      SHA256_W[i] = view.getUint32(offset, false);
-    for (let i = 16;i < 64; i++) {
-      const W15 = SHA256_W[i - 15];
-      const W2 = SHA256_W[i - 2];
-      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-    }
-    let { A, B, C, D, E, F, G, H } = this;
-    for (let i = 0;i < 64; i++) {
-      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-      const T2 = sigma0 + Maj(A, B, C) | 0;
-      H = G;
-      G = F;
-      F = E;
-      E = D + T1 | 0;
-      D = C;
-      C = B;
-      B = A;
-      A = T1 + T2 | 0;
-    }
-    A = A + this.A | 0;
-    B = B + this.B | 0;
-    C = C + this.C | 0;
-    D = D + this.D | 0;
-    E = E + this.E | 0;
-    F = F + this.F | 0;
-    G = G + this.G | 0;
-    H = H + this.H | 0;
-    this.set(A, B, C, D, E, F, G, H);
-  }
-  roundClean() {
-    SHA256_W.fill(0);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    this.buffer.fill(0);
-  }
-}
-var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256);
-
-// ../done-client/src/envelope.ts
+// ../done-client/src/envelope-builder.ts
 function normalizeMetadata(metadata) {
   if (!metadata)
     return;
@@ -27833,21 +27524,6 @@ function normalizeMetadata(metadata) {
     normalized.gas_limit = metadata.gas_limit;
   return Object.keys(normalized).length > 0 ? normalized : undefined;
 }
-function toSignDoc(envelope) {
-  const metadata = normalizeMetadata(envelope.metadata);
-  return {
-    version: envelope.version ?? CURRENT_ENVELOPE_VERSION,
-    user_id: envelope.user_id,
-    session_id: envelope.session_id,
-    msgs: envelope.msgs.map((msg) => cloneMsg(msg)),
-    nonce: envelope.nonce,
-    expires_at: envelope.expires_at,
-    role: envelope.role,
-    agent: envelope.agent,
-    forwarder: envelope.forwarder,
-    metadata
-  };
-}
 function buildEnvelope(draft) {
   if (!Array.isArray(draft.msgs) || draft.msgs.length === 0) {
     throw new Error("envelope requires at least one message");
@@ -27868,32 +27544,9 @@ function buildEnvelope(draft) {
     metadata
   };
 }
-function signDocBytes(signDoc) {
-  const json = canonicalStringify(signDoc);
-  return new TextEncoder().encode(json);
-}
-function signDocDigest(signDoc) {
-  const bytes2 = signDocBytes(signDoc);
-  return sha256(bytes2);
-}
 function cloneMsg(msg) {
   return structuredClone(msg);
 }
-function canonicalStringify(value) {
-  return JSON.stringify(value, (_key, val) => {
-    if (val instanceof Map) {
-      return Object.fromEntries(Array.from(val.entries()).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
-    }
-    if (val && typeof val === "object" && !Array.isArray(val)) {
-      const entries = Object.entries(val).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-      return entries.reduce((acc, [key, entry]) => {
-        acc[key] = entry;
-        return acc;
-      }, {});
-    }
-    return val;
-  });
-}
 var CURRENT_ENVELOPE_VERSION = 1;
 
 // ../done-client/src/messages.ts
@@ -28084,490 +27737,6 @@ class DoneContractHandle {
     }, init);
   }
 }
-// ../done-client/src/done.ts
-function mergeMetadata(...entries) {
-  const merged = {};
-  for (const entry of entries) {
-    if (!entry)
-      continue;
-    if (entry.trace_id)
-      merged.trace_id = entry.trace_id;
-    if (entry.memo)
-      merged.memo = entry.memo;
-    if (typeof entry.gas_limit === "number")
-      merged.gas_limit = entry.gas_limit;
-  }
-  return Object.keys(merged).length > 0 ? merged : undefined;
-}
-function mergeExecuteOptions(base, overrides) {
-  if (!base && !overrides.memo && !overrides.passkey && !overrides.signal) {
-    return;
-  }
-  return {
-    memo: overrides.memo ?? base?.memo,
-    passkey: overrides.passkey ?? base?.passkey,
-    signal: overrides.signal ?? base?.signal
-  };
-}
-function defaultEventSourceFactory(url) {
-  if (typeof EventSource === "undefined") {
-    throw new Error("EventSource is not available in this environment");
-  }
-  return new EventSource(url);
-}
-function buildEventsUrl(baseUrl, eventsPath) {
-  const normalized = eventsPath.startsWith("/") ? eventsPath : `/${eventsPath}`;
-  return `${baseUrl.replace(/\/$/, "")}${normalized}`;
-}
-function resolveFetch(fn) {
-  if (fn) {
-    return typeof fn === "function" ? fn : (() => {
-      throw new Error("provided fetch implementation is not a function");
-    })();
-  }
-  if (typeof fetch === "function") {
-    return fetch.bind(globalThis);
-  }
-  throw new Error("global fetch is not available; configure Done with a fetch implementation via Done.config");
-}
-function resolveEventSource(factory) {
-  if (factory)
-    return factory;
-  if (typeof EventSource === "function") {
-    return (url) => new EventSource(url);
-  }
-  return;
-}
-function normalizeConfig(input = {}, base) {
-  const previous = base ?? {
-    doneHttp: "https://doneHttp.done.zone",
-    doneEvents: "https://doneEvents.done.zone",
-    fetch: resolveFetch(),
-    eventSource: resolveEventSource(),
-    envelopeBuilder: undefined
-  };
-  return {
-    doneHttp: input.doneHttp ?? previous.doneHttp,
-    doneEvents: input.doneEvents ?? previous.doneEvents,
-    fetch: resolveFetch(input.fetch ?? previous.fetch),
-    eventSource: resolveEventSource(input.eventSource ?? previous.eventSource),
-    envelopeBuilder: input.envelopeBuilder ?? input.signer ?? previous.envelopeBuilder
-  };
-}
-function resolveRoute(raw, base, extraSearch) {
-  const url = new URL(raw, base);
-  if (extraSearch) {
-    for (const [key, value] of Object.entries(extraSearch)) {
-      url.searchParams.set(key, String(value));
-    }
-  }
-  const pathSegments = url.pathname.replace(/^\/+/, "").split("/");
-  const contract = pathSegments.shift();
-  if (!contract) {
-    throw new Error("route must include contract address as first path segment");
-  }
-  const path = pathSegments.length > 0 ? `/${pathSegments.join("/")}` : "/";
-  const queryRecord = searchParamsToRecord(url.searchParams);
-  return {
-    url,
-    contract,
-    path,
-    query: Object.keys(queryRecord).length > 0 ? queryRecord : undefined
-  };
-}
-function searchParamsToRecord(params) {
-  const record = {};
-  for (const [key, value] of params) {
-    const existing = record[key];
-    if (existing === undefined) {
-      record[key] = value;
-    } else if (Array.isArray(existing)) {
-      existing.push(value);
-    } else {
-      record[key] = [existing, value];
-    }
-  }
-  return record;
-}
-function normalizeContractBody(body) {
-  if (body === undefined || body === null) {
-    return body;
-  }
-  if (isPlainObject(body) || Array.isArray(body)) {
-    return body;
-  }
-  if (typeof body === "string") {
-    try {
-      return JSON.parse(body);
-    } catch (err) {
-      throw new Error("string bodies must contain JSON payloads when invoking Done.run/query");
-    }
-  }
-  if (body instanceof URLSearchParams) {
-    return Object.fromEntries(Array.from(body));
-  }
-  throw new Error("unsupported body type for Done.run/query; provide a JSON-serialisable value");
-}
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object")
-    return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-function normalizeContractSegment(value) {
-  if (!value) {
-    throw new Error("contract identifier cannot be empty");
-  }
-  return value.replace(/^\/+/u, "").replace(/\/+$/u, "");
-}
-
-class DoneContractClient {
-  backend;
-  address;
-  buildEnvelopeFn;
-  eventSourceFactory;
-  eventsPath;
-  defaultMetadata;
-  constructor(config) {
-    this.backend = new DoneBackendClient({ baseUrl: config.baseUrl, fetch: config.fetch });
-    this.address = config.address;
-    this.buildEnvelopeFn = config.buildEnvelope;
-    this.eventSourceFactory = config.eventSource;
-    this.eventsPath = config.eventsPath ?? "/events";
-    this.defaultMetadata = config.defaultMetadata;
-  }
-  get(path, request = {}, init = {}) {
-    const promise = this.fetchQuery(path, request, init);
-    return new DoneRequest(promise);
-  }
-  async query(path, request = {}, init = {}) {
-    const response = await this.fetchQuery(path, request, init);
-    return response.json();
-  }
-  async post(path, request = {}, init = {}) {
-    return this.execute(path, request, init);
-  }
-  async run(path, request = {}, init = {}) {
-    return this.execute(path, request, init);
-  }
-  async execute(path, request = {}, init = {}) {
-    if (!this.buildEnvelopeFn) {
-      throw new Error("execute requires a buildEnvelope function in contract config");
-    }
-    const normalizedCall = {
-      path,
-      query: request.query,
-      body: request.body
-    };
-    const transactionMsg = buildTransactionMessage(this.address, normalizedCall, request);
-    const metadata = mergeMetadata(this.defaultMetadata, request.metadata, { trace_id: request.traceId, memo: request.memo, gas_limit: request.gasLimit });
-    const buildContext = {
-      msg: transactionMsg,
-      metadata,
-      path,
-      request
-    };
-    const buildResult = await this.buildEnvelopeFn(buildContext);
-    if (metadata) {
-      buildResult.envelope.metadata = buildResult.envelope.metadata ?? metadata;
-    }
-    const executeOptions = mergeExecuteOptions(buildResult.options, {
-      memo: request.memo,
-      passkey: request.passkey,
-      signal: request.signal
-    });
-    return this.backend.executeEnvelope(buildResult.envelope, executeOptions, init);
-  }
-  transaction(path, request = {}) {
-    const normalizedCall = {
-      path,
-      query: request.query,
-      body: request.body
-    };
-    const msg = buildTransactionMessage(this.address, normalizedCall, request);
-    const metadata = mergeMetadata(this.defaultMetadata, request.metadata, {
-      trace_id: request.traceId,
-      memo: request.memo,
-      gas_limit: request.gasLimit
-    });
-    return { msg, metadata };
-  }
-  subscribe(topic, handler, options = {}) {
-    const factory = this.eventSourceFactory ?? defaultEventSourceFactory;
-    const eventsBase = buildEventsUrl(this.backend.baseUrl, this.eventsPath);
-    const encodedTopic = Array.isArray(topic) ? JSON.stringify(topic) : topic;
-    const url = `${eventsBase}?topic=${encodeURIComponent(encodedTopic)}`;
-    const source = factory(url);
-    const messageListener = (event) => {
-      if (options.rawEvent) {
-        handler(event);
-        return;
-      }
-      const data = event.data;
-      try {
-        handler(JSON.parse(data));
-      } catch {
-        handler(data);
-      }
-    };
-    if (typeof source.addEventListener === "function") {
-      source.addEventListener("message", messageListener);
-    } else {
-      source.onmessage = messageListener;
-    }
-    if (options.onError) {
-      if (typeof source.addEventListener === "function") {
-        source.addEventListener("error", options.onError);
-      } else {
-        source.onerror = options.onError;
-      }
-    }
-    const cleanup = () => {
-      if (typeof source.removeEventListener === "function") {
-        source.removeEventListener("message", messageListener);
-        if (options.onError) {
-          source.removeEventListener("error", options.onError);
-        }
-      }
-      source.close();
-    };
-    if (options.signal) {
-      if (options.signal.aborted) {
-        cleanup();
-      } else {
-        options.signal.addEventListener("abort", cleanup, { once: true });
-      }
-    }
-    return cleanup;
-  }
-  publishCode(request, init = {}) {
-    return this.backend.publishCode({
-      contract: this.address,
-      script: request.script,
-      msg: request.msg
-    }, init);
-  }
-  buildEnvelope(draft) {
-    return buildEnvelope(draft);
-  }
-  signDocDigest(envelope) {
-    return signDocDigest(toSignDoc(envelope));
-  }
-  get baseUrl() {
-    return this.backend.baseUrl;
-  }
-  async fetchQuery(path, request, init = {}) {
-    const call = { path, query: request.query, body: request.body };
-    return this.backend.queryContractRaw(this.address, call, init);
-  }
-}
-
-class DoneRequest {
-  promise;
-  constructor(promise) {
-    this.promise = promise;
-  }
-  then(onfulfilled, onrejected) {
-    return this.promise.then(onfulfilled, onrejected);
-  }
-  catch(onrejected) {
-    return this.promise.catch(onrejected);
-  }
-  finally(onfinally) {
-    return this.promise.finally(onfinally);
-  }
-  json() {
-    return this.promise.then((response) => response.json());
-  }
-  text() {
-    return this.promise.then((response) => response.text());
-  }
-  arrayBuffer() {
-    return this.promise.then((response) => response.arrayBuffer());
-  }
-}
-
-class DoneInstance {
-  settings;
-  backend;
-  CURRENT_ENVELOPE_VERSION = CURRENT_ENVELOPE_VERSION;
-  buildEnvelope = buildEnvelope;
-  signDocDigest = signDocDigest;
-  toSignDoc = toSignDoc;
-  constructor(input) {
-    this.settings = normalizeConfig(input);
-    this.backend = new DoneBackendClient({ baseUrl: this.settings.doneHttp, fetch: this.settings.fetch });
-  }
-  async run(url, init = {}) {
-    const {
-      body: rawBody,
-      funds,
-      memo,
-      traceId,
-      gasLimit,
-      passkey,
-      metadata,
-      search,
-      ...rest
-    } = init;
-    const fetchInit = { ...rest };
-    const resolved = resolveRoute(url, this.settings.doneHttp, search);
-    const contractBody = normalizeContractBody(rawBody);
-    const call = {
-      path: resolved.path,
-      query: resolved.query,
-      body: contractBody
-    };
-    const msg = buildTransactionMessage(resolved.contract, call, { funds });
-    const mergedMetadata = mergeMetadata(metadata, {
-      trace_id: traceId,
-      memo,
-      gas_limit: gasLimit
-    });
-    const builder = this.requireEnvelopeBuilder();
-    const request = {
-      body: contractBody,
-      query: resolved.query,
-      funds,
-      memo,
-      traceId,
-      gasLimit,
-      metadata: mergedMetadata,
-      passkey,
-      signal: fetchInit.signal
-    };
-    const result = await Promise.resolve(builder({
-      msg,
-      metadata: mergedMetadata,
-      path: resolved.path,
-      request
-    }));
-    if (mergedMetadata) {
-      result.envelope.metadata = result.envelope.metadata ?? mergedMetadata;
-    }
-    const executeOptions = mergeExecuteOptions(result.options, {
-      memo,
-      passkey,
-      signal: fetchInit.signal
-    });
-    return this.backend.executeEnvelope(result.envelope, executeOptions ?? {}, fetchInit);
-  }
-  async query(url, init = {}) {
-    const { body: rawBody, search, ...rest } = init;
-    const fetchInit = { ...rest };
-    const resolved = resolveRoute(url, this.settings.doneHttp, search);
-    const contractBody = normalizeContractBody(rawBody);
-    const call = {
-      path: resolved.path,
-      query: resolved.query,
-      body: contractBody
-    };
-    return this.backend.queryContract(resolved.contract, call, fetchInit);
-  }
-  subscribe(eventsUrl, topic, handler, options = {}) {
-    const factory = this.settings.eventSource ?? defaultEventSourceFactory;
-    if (!factory) {
-      throw new Error("EventSource is not available; configure Done with an eventSource factory");
-    }
-    const url = new URL(eventsUrl, this.settings.doneEvents);
-    const topicValue = Array.isArray(topic) ? JSON.stringify(topic) : topic;
-    url.searchParams.set("topic", topicValue);
-    const source = factory(url.toString());
-    const messageListener = (event) => {
-      if (options.rawEvent) {
-        handler(event);
-        return;
-      }
-      try {
-        handler(JSON.parse(event.data));
-      } catch {
-        handler(event.data);
-      }
-    };
-    if (typeof source.addEventListener === "function") {
-      source.addEventListener("message", messageListener);
-    } else {
-      source.onmessage = messageListener;
-    }
-    if (options.onError) {
-      if (typeof source.addEventListener === "function") {
-        source.addEventListener("error", options.onError);
-      } else {
-        source.onerror = options.onError;
-      }
-    }
-    const cleanup = () => {
-      if (typeof source.removeEventListener === "function") {
-        source.removeEventListener("message", messageListener);
-        if (options.onError) {
-          source.removeEventListener("error", options.onError);
-        }
-      }
-      source.close();
-    };
-    if (options.signal) {
-      if (options.signal.aborted) {
-        cleanup();
-      } else {
-        options.signal.addEventListener("abort", cleanup, { once: true });
-      }
-    }
-    return cleanup;
-  }
-  config(update) {
-    this.settings = normalizeConfig(update, this.settings);
-    this.backend = new DoneBackendClient({ baseUrl: this.settings.doneHttp, fetch: this.settings.fetch });
-  }
-  create(update = {}) {
-    const merged = normalizeConfig(update, this.settings);
-    return new DoneInstance({
-      doneHttp: merged.doneHttp,
-      doneEvents: merged.doneEvents,
-      fetch: merged.fetch,
-      eventSource: merged.eventSource,
-      envelopeBuilder: merged.envelopeBuilder
-    });
-  }
-  contract(config, maybeConfig) {
-    if (typeof config === "string") {
-      if (!maybeConfig) {
-        return this.buildContractHandle(config);
-      }
-      return new DoneContractClient({
-        baseUrl: config,
-        ...maybeConfig,
-        buildEnvelope: maybeConfig.buildEnvelope ?? this.settings.envelopeBuilder,
-        fetch: maybeConfig.fetch ?? this.settings.fetch,
-        eventSource: maybeConfig.eventSource ?? this.settings.eventSource
-      });
-    }
-    return new DoneContractClient({
-      ...config,
-      baseUrl: config.baseUrl,
-      buildEnvelope: config.buildEnvelope ?? this.settings.envelopeBuilder,
-      fetch: config.fetch ?? this.settings.fetch,
-      eventSource: config.eventSource ?? this.settings.eventSource
-    });
-  }
-  requireEnvelopeBuilder() {
-    if (!this.settings.envelopeBuilder) {
-      throw new Error("Done.run requires an envelope builder; configure Done.config({ signer: ... }) first");
-    }
-    return this.settings.envelopeBuilder;
-  }
-  buildContractHandle(contract) {
-    const address = normalizeContractSegment(contract);
-    const client = new DoneContractClient({
-      baseUrl: this.settings.doneHttp,
-      address,
-      buildEnvelope: this.settings.envelopeBuilder,
-      fetch: this.settings.fetch,
-      eventSource: this.settings.eventSource
-    });
-    return client;
-  }
-}
-var Done = new DoneInstance;
 // ../done-local-chain/src/chain.ts
 var import_cosmwasm_vm_js = __toESM(require_dist2(), 1);
 var import_encoding = __toESM(require_build2(), 1);
@@ -28575,8 +27744,8 @@ var import_backend = __toESM(require_backend(), 1);
 var import_bech32 = __toESM(require_dist(), 1);
 
 // ../done-local-chain/src/proto.ts
-function decodeAny(bytes2) {
-  const reader = new BinaryReader(bytes2);
+function decodeAny(bytes) {
+  const reader = new BinaryReader(bytes);
   const any = { typeUrl: "", value: new Uint8Array };
   while (!reader.eof()) {
     const tag = reader.uint32();
@@ -28594,8 +27763,8 @@ function decodeAny(bytes2) {
   }
   return any;
 }
-function decodeMsgExecuteContract(bytes2) {
-  const reader = new BinaryReader(bytes2);
+function decodeMsgExecuteContract(bytes) {
+  const reader = new BinaryReader(bytes);
   const message = {
     sender: "",
     contract: "",
@@ -28632,8 +27801,8 @@ function encodeMsgExecuteContractResponse(data) {
   }
   return writer.finish();
 }
-function decodeCoin(bytes2) {
-  const reader = new BinaryReader(bytes2);
+function decodeCoin(bytes) {
+  const reader = new BinaryReader(bytes);
   const coin = { denom: "", amount: "" };
   while (!reader.eof()) {
     const tag = reader.uint32();
@@ -28651,11 +27820,11 @@ function decodeCoin(bytes2) {
   }
   return coin;
 }
-function decodeJsonMsg(bytes2) {
-  if (!bytes2 || bytes2.length === 0) {
+function decodeJsonMsg(bytes) {
+  if (!bytes || bytes.length === 0) {
     return {};
   }
-  const jsonStr = textDecoder.decode(bytes2);
+  const jsonStr = textDecoder.decode(bytes);
   return jsonStr ? JSON.parse(jsonStr) : {};
 }
 function toCoins(funds) {
@@ -28669,8 +27838,8 @@ var WASMVM_STARGATE_EXECUTE_PATH = "/wasmvm/execute";
 class BinaryReader {
   buf;
   offset = 0;
-  constructor(bytes2) {
-    this.buf = bytes2;
+  constructor(bytes) {
+    this.buf = bytes;
   }
   uint32() {
     let value = 0;
@@ -28753,10 +27922,10 @@ class BinaryWriter {
 }
 
 // ../done-local-chain/src/querier.ts
-function encodeSuccess(bytes2) {
+function encodeSuccess(bytes) {
   const payload = {
     ok: {
-      ok: Buffer.from(bytes2).toString("base64")
+      ok: Buffer.from(bytes).toString("base64")
     }
   };
   return textEncoder2.encode(JSON.stringify(payload));
@@ -28862,8 +28031,8 @@ function readArtifactFromDisk(name) {
   if (!existsSync(artifactPath)) {
     throw new Error(`Artifact '${filename}' not found in ${ARTIFACTS_DIR}`);
   }
-  const bytes2 = readFileSync(artifactPath);
-  return new Uint8Array(bytes2);
+  const bytes = readFileSync(artifactPath);
+  return new Uint8Array(bytes);
 }
 function loadArtifact(name) {
   if (!cache.has(name)) {
@@ -28881,8 +28050,8 @@ var ARTIFACTS_DIR = resolveArtifactsDir();
 var cache = new Map;
 
 // ../done-local-chain/src/batteries.ts
-function sha2562(bytes2) {
-  return createHash("sha256").update(bytes2).digest("hex");
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
 }
 function installDoneLocalBatteries(chain) {
   const selected = DEFAULT_ARTIFACTS;
@@ -28893,7 +28062,7 @@ function installDoneLocalBatteries(chain) {
     installs.set(name, {
       name,
       codeId,
-      checksum: sha2562(wasm)
+      checksum: sha256(wasm)
     });
   }
   const get = (name) => {
@@ -28959,9 +28128,9 @@ class DoneLocalChain {
     };
   }
   storeCode(wasm) {
-    const bytes2 = wasm instanceof Uint8Array ? new Uint8Array(wasm) : new Uint8Array(wasm);
+    const bytes = wasm instanceof Uint8Array ? new Uint8Array(wasm) : new Uint8Array(wasm);
     const id = this.nextCodeId++;
-    this.codes.set(id, bytes2);
+    this.codes.set(id, bytes);
     return id;
   }
   async instantiate(codeId, options) {
@@ -32442,7 +31611,7 @@ function FNV1A64(byte) {
   Accumulator = Accumulator ^ Bytes[byte];
   Accumulator = Accumulator * Prime % Size;
 }
-function Hash2(value) {
+function Hash(value) {
   Accumulator = BigInt("14695981039346656037");
   Visit4(value);
   return Accumulator;
@@ -32504,7 +31673,7 @@ function FromArray7(schema, references, value) {
   if (schema.uniqueItems === true && !function() {
     const set = new Set;
     for (const element of value) {
-      const hashed = Hash2(element);
+      const hashed = Hash(element);
       if (set.has(hashed)) {
         return false;
       } else {
@@ -32945,7 +32114,7 @@ function* FromArray8(schema, references, path, value) {
   if (schema.uniqueItems === true && !function() {
     const set = new Set;
     for (const element of value) {
-      const hashed = Hash2(element);
+      const hashed = Hash(element);
       if (set.has(hashed)) {
         return false;
       } else {
@@ -33966,8 +33135,8 @@ function ScoreUnion(schema, references, value) {
     return entries.reduce((acc, [key, schema2]) => {
       const literal = schema2[Kind] === "Literal" && schema2.const === value[key] ? 100 : 0;
       const checks = Check(schema2, references, value[key]) ? 10 : 0;
-      const exists2 = keys.includes(key) ? 1 : 0;
-      return acc + (literal + checks + exists2);
+      const exists = keys.includes(key) ? 1 : 0;
+      return acc + (literal + checks + exists);
     }, 0);
   } else if (schema[Kind] === "Union") {
     const schemas = schema.anyOf.map((schema2) => Deref(schema2, references));
@@ -35496,7 +34665,7 @@ __export(exports_value2, {
   Patch: () => Patch,
   Parse: () => Parse,
   Mutate: () => Mutate,
-  Hash: () => Hash2,
+  Hash: () => Hash,
   Errors: () => Errors,
   Equal: () => Equal,
   Encode: () => Encode,
@@ -36076,7 +35245,7 @@ var TypeCompiler;
       return checkFunc(value);
     }
     function hashFunction(value) {
-      return Hash2(value);
+      return Hash(value);
     }
     const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, hashFunction);
     return new TypeCheck(schema, references, checkFunction, generatedCode);
@@ -44042,13 +43211,13 @@ var derivePath = (rawType) => {
   }
   return segments;
 };
-var normalizeLocalEvent = (event, context) => {
+var normalizeLocalEvent = (event, context, contractFallback) => {
   if (!event)
     return;
   const rawAttributes = event.attributes ?? [];
   const normalizedAttributes = {};
   const passthroughAttributes = [];
-  let contract;
+  let contract = contractFallback;
   for (const attribute of rawAttributes) {
     if (!attribute)
       continue;
@@ -44114,7 +43283,7 @@ function createDoneEventsLocalServer(options) {
       const normalized = normalizeLocalEvent(entry, {
         height: event.height,
         blockTime: event.blockTime
-      });
+      }, event.contract);
       if (!normalized)
         continue;
       pubsub.publish(normalized.publishPath, normalized.payload);
@@ -44396,12 +43565,13 @@ async function scaffoldWorkspace(rawName, options) {
     await runCommand("bun", ["install"], { cwd: targetDir });
   }
   console.log(`Done workspace created at ${path.relative(cwd, targetDir) || "."}.`);
-  console.log("Next steps:");
-  console.log(`  cd ${path.relative(cwd, targetDir) || slug}`);
   if (options.install === false) {
-    console.log("  bun install");
+    console.log("Skipping dev server (--no-install was set). Run `bun install && bunx done dev` to get started.");
+    return;
   }
-  console.log("  bunx done dev");
+  console.log("Starting dev server\u2026");
+  process.chdir(targetDir);
+  await handleDev({});
 }
 async function scaffoldContract(workspace, rawName, options) {
   const slug = toSlug(rawName);
@@ -44720,11 +43890,11 @@ async function runBunBuild(entryPath, outFilePath) {
       const logs = (result.logs ?? []).map((log) => log?.message ?? String(log));
       throw new Error(logs.join("\n") || "Bun.build failed");
     }
-    const [output2] = result.outputs;
-    if (!output2) {
+    const [output] = result.outputs;
+    if (!output) {
       throw new Error("Bun.build did not emit an output file");
     }
-    const bundledSource = await output2.text();
+    const bundledSource = await output.text();
     await fs.writeFile(outFilePath, bundledSource);
     return;
   }
@@ -44812,11 +43982,11 @@ function decodeUtf8FromBase64(base64) {
   if (!base64)
     return;
   try {
-    const bytes2 = Buffer.from(base64, "base64");
-    if (bytes2.length === 0) {
+    const bytes = Buffer.from(base64, "base64");
+    if (bytes.length === 0) {
       return "";
     }
-    return utf8Decoder2.decode(bytes2);
+    return utf8Decoder2.decode(bytes);
   } catch {
     return;
   }