@donezone/cli 0.1.46 → 0.1.49

package/dist/index.js

@@ -34,6 +34,7 @@ var require_constants = __commonJS((exports, module) => {
   var path = __require("path");
   var WIN_SLASH = "\\\\/";
   var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+  var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
   var DOT_LITERAL = "\\.";
   var PLUS_LITERAL = "\\+";
   var QMARK_LITERAL = "\\?";
@@ -81,6 +82,7 @@ var require_constants = __commonJS((exports, module) => {
     END_ANCHOR: `(?:[${WIN_SLASH}]|\$)`
   };
   var POSIX_REGEX_SOURCE = {
+    __proto__: null,
     alnum: "a-zA-Z0-9",
     alpha: "a-zA-Z",
     ascii: "\\x00-\\x7F",
@@ -97,6 +99,7 @@ var require_constants = __commonJS((exports, module) => {
     xdigit: "A-Fa-f0-9"
   };
   module.exports = {
+    DEFAULT_MAX_EXTGLOB_RECURSION,
     MAX_LENGTH: 1024 * 64,
     POSIX_REGEX_SOURCE,
     REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
@@ -106,6 +109,7 @@ var require_constants = __commonJS((exports, module) => {
     REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
     REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
     REPLACEMENTS: {
+      __proto__: null,
       "***": "*",
       "**/**": "**",
       "**/**/**": "**"
@@ -571,6 +575,213 @@ var require_parse = __commonJS((exports, module) => {
   var syntaxError = (type, char) => {
     return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
   };
+  var splitTopLevel = (input) => {
+    const parts = [];
+    let bracket = 0;
+    let paren = 0;
+    let quote = 0;
+    let value = "";
+    let escaped = false;
+    for (const ch of input) {
+      if (escaped === true) {
+        value += ch;
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        value += ch;
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        quote = quote === 1 ? 0 : 1;
+        value += ch;
+        continue;
+      }
+      if (quote === 0) {
+        if (ch === "[") {
+          bracket++;
+        } else if (ch === "]" && bracket > 0) {
+          bracket--;
+        } else if (bracket === 0) {
+          if (ch === "(") {
+            paren++;
+          } else if (ch === ")" && paren > 0) {
+            paren--;
+          } else if (ch === "|" && paren === 0) {
+            parts.push(value);
+            value = "";
+            continue;
+          }
+        }
+      }
+      value += ch;
+    }
+    parts.push(value);
+    return parts;
+  };
+  var isPlainBranch = (branch) => {
+    let escaped = false;
+    for (const ch of branch) {
+      if (escaped === true) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (/[?*+@!()[\]{}]/.test(ch)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  var normalizeSimpleBranch = (branch) => {
+    let value = branch.trim();
+    let changed = true;
+    while (changed === true) {
+      changed = false;
+      if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+        value = value.slice(2, -1);
+        changed = true;
+      }
+    }
+    if (!isPlainBranch(value)) {
+      return;
+    }
+    return value.replace(/\\(.)/g, "$1");
+  };
+  var hasRepeatedCharPrefixOverlap = (branches) => {
+    const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+    for (let i = 0;i < values.length; i++) {
+      for (let j = i + 1;j < values.length; j++) {
+        const a = values[i];
+        const b = values[j];
+        const char = a[0];
+        if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+          continue;
+        }
+        if (a === b || a.startsWith(b) || b.startsWith(a)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  var parseRepeatedExtglob = (pattern, requireEnd = true) => {
+    if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
+      return;
+    }
+    let bracket = 0;
+    let paren = 0;
+    let quote = 0;
+    let escaped = false;
+    for (let i = 1;i < pattern.length; i++) {
+      const ch = pattern[i];
+      if (escaped === true) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        quote = quote === 1 ? 0 : 1;
+        continue;
+      }
+      if (quote === 1) {
+        continue;
+      }
+      if (ch === "[") {
+        bracket++;
+        continue;
+      }
+      if (ch === "]" && bracket > 0) {
+        bracket--;
+        continue;
+      }
+      if (bracket > 0) {
+        continue;
+      }
+      if (ch === "(") {
+        paren++;
+        continue;
+      }
+      if (ch === ")") {
+        paren--;
+        if (paren === 0) {
+          if (requireEnd === true && i !== pattern.length - 1) {
+            return;
+          }
+          return {
+            type: pattern[0],
+            body: pattern.slice(2, i),
+            end: i
+          };
+        }
+      }
+    }
+  };
+  var getStarExtglobSequenceOutput = (pattern) => {
+    let index = 0;
+    const chars = [];
+    while (index < pattern.length) {
+      const match = parseRepeatedExtglob(pattern.slice(index), false);
+      if (!match || match.type !== "*") {
+        return;
+      }
+      const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
+      if (branches.length !== 1) {
+        return;
+      }
+      const branch = normalizeSimpleBranch(branches[0]);
+      if (!branch || branch.length !== 1) {
+        return;
+      }
+      chars.push(branch);
+      index += match.end + 1;
+    }
+    if (chars.length < 1) {
+      return;
+    }
+    const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+    return `${source}*`;
+  };
+  var repeatedExtglobRecursion = (pattern) => {
+    let depth = 0;
+    let value = pattern.trim();
+    let match = parseRepeatedExtglob(value);
+    while (match) {
+      depth++;
+      value = match.body.trim();
+      match = parseRepeatedExtglob(value);
+    }
+    return depth;
+  };
+  var analyzeRepeatedExtglob = (body, options) => {
+    if (options.maxExtglobRecursion === false) {
+      return { risky: false };
+    }
+    const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+    const branches = splitTopLevel(body).map((branch) => branch.trim());
+    if (branches.length > 1) {
+      if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
+        return { risky: true };
+      }
+    }
+    for (const branch of branches) {
+      const safeOutput = getStarExtglobSequenceOutput(branch);
+      if (safeOutput) {
+        return { risky: true, safeOutput };
+      }
+      if (repeatedExtglobRecursion(branch) > max) {
+        return { risky: true };
+      }
+    }
+    return { risky: false };
+  };
   var parse = (input, options) => {
     if (typeof input !== "string") {
       throw new TypeError("Expected a string");
@@ -703,6 +914,8 @@ var require_parse = __commonJS((exports, module) => {
       token.prev = prev;
       token.parens = state.parens;
       token.output = state.output;
+      token.startIndex = state.index;
+      token.tokensIndex = tokens.length;
       const output = (opts.capture ? "(" : "") + token.open;
       increment("parens");
       push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
@@ -710,6 +923,26 @@ var require_parse = __commonJS((exports, module) => {
       extglobs.push(token);
     };
     const extglobClose = (token) => {
+      const literal = input.slice(token.startIndex, state.index + 1);
+      const body = input.slice(token.startIndex + 2, state.index);
+      const analysis = analyzeRepeatedExtglob(body, opts);
+      if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+        const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : undefined;
+        const open = tokens[token.tokensIndex];
+        open.type = "text";
+        open.value = literal;
+        open.output = safeOutput || utils.escapeRegex(literal);
+        for (let i = token.tokensIndex + 1;i < tokens.length; i++) {
+          tokens[i].value = "";
+          tokens[i].output = "";
+          delete tokens[i].suffix;
+        }
+        state.output = token.output + open.output;
+        state.backtrack = true;
+        push({ type: "paren", extglob: true, value, output: "" });
+        decrement("parens");
+        return;
+      }
       let output = token.close + (opts.capture ? ")" : "");
       let rest;
       if (token.type === "negate") {
@@ -21452,6 +21685,452 @@ var require_dist2 = __commonJS((exports) => {
   global.eddsa = () => global._eddsa || (global._eddsa = new elliptic_1.eddsa("ed25519"));
 });
 
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/ascii.js
+var require_ascii2 = __commonJS((exports) => {
+  function toAscii(input) {
+    const toNums = (str) => str.split("").map((x) => {
+      const charCode = x.charCodeAt(0);
+      if (charCode < 32 || charCode > 126) {
+        throw new Error("Cannot encode character that is out of printable ASCII range: " + charCode);
+      }
+      return charCode;
+    });
+    return Uint8Array.from(toNums(input));
+  }
+  function fromAscii(data) {
+    const fromNums = (listOfNumbers) => listOfNumbers.map((x) => {
+      if (x < 32 || x > 126) {
+        throw new Error("Cannot decode character that is out of printable ASCII range: " + x);
+      }
+      return String.fromCharCode(x);
+    });
+    return fromNums(Array.from(data)).join("");
+  }
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromAscii = exports.toAscii = undefined;
+  exports.toAscii = toAscii;
+  exports.fromAscii = fromAscii;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/base64.js
+var require_base642 = __commonJS((exports) => {
+  function toBase64(data) {
+    return base64js.fromByteArray(data);
+  }
+  function fromBase64(base64String) {
+    if (!base64String.match(/^[a-zA-Z0-9+/]*={0,2}$/)) {
+      throw new Error("Invalid base64 string format");
+    }
+    return base64js.toByteArray(base64String);
+  }
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromBase64 = exports.toBase64 = undefined;
+  var base64js = __importStar(require_base64_js());
+  exports.toBase64 = toBase64;
+  exports.fromBase64 = fromBase64;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/node_modules/bech32/index.js
+var require_bech323 = __commonJS((exports, module) => {
+  function polymodStep(pre) {
+    var b = pre >> 25;
+    return (pre & 33554431) << 5 ^ -(b >> 0 & 1) & 996825010 ^ -(b >> 1 & 1) & 642813549 ^ -(b >> 2 & 1) & 513874426 ^ -(b >> 3 & 1) & 1027748829 ^ -(b >> 4 & 1) & 705979059;
+  }
+  function prefixChk(prefix) {
+    var chk = 1;
+    for (var i = 0;i < prefix.length; ++i) {
+      var c = prefix.charCodeAt(i);
+      if (c < 33 || c > 126)
+        return "Invalid prefix (" + prefix + ")";
+      chk = polymodStep(chk) ^ c >> 5;
+    }
+    chk = polymodStep(chk);
+    for (i = 0;i < prefix.length; ++i) {
+      var v = prefix.charCodeAt(i);
+      chk = polymodStep(chk) ^ v & 31;
+    }
+    return chk;
+  }
+  function encode(prefix, words, LIMIT) {
+    LIMIT = LIMIT || 90;
+    if (prefix.length + 7 + words.length > LIMIT)
+      throw new TypeError("Exceeds length limit");
+    prefix = prefix.toLowerCase();
+    var chk = prefixChk(prefix);
+    if (typeof chk === "string")
+      throw new Error(chk);
+    var result = prefix + "1";
+    for (var i = 0;i < words.length; ++i) {
+      var x2 = words[i];
+      if (x2 >> 5 !== 0)
+        throw new Error("Non 5-bit word");
+      chk = polymodStep(chk) ^ x2;
+      result += ALPHABET.charAt(x2);
+    }
+    for (i = 0;i < 6; ++i) {
+      chk = polymodStep(chk);
+    }
+    chk ^= 1;
+    for (i = 0;i < 6; ++i) {
+      var v = chk >> (5 - i) * 5 & 31;
+      result += ALPHABET.charAt(v);
+    }
+    return result;
+  }
+  function __decode(str, LIMIT) {
+    LIMIT = LIMIT || 90;
+    if (str.length < 8)
+      return str + " too short";
+    if (str.length > LIMIT)
+      return "Exceeds length limit";
+    var lowered = str.toLowerCase();
+    var uppered = str.toUpperCase();
+    if (str !== lowered && str !== uppered)
+      return "Mixed-case string " + str;
+    str = lowered;
+    var split = str.lastIndexOf("1");
+    if (split === -1)
+      return "No separator character for " + str;
+    if (split === 0)
+      return "Missing prefix for " + str;
+    var prefix = str.slice(0, split);
+    var wordChars = str.slice(split + 1);
+    if (wordChars.length < 6)
+      return "Data too short";
+    var chk = prefixChk(prefix);
+    if (typeof chk === "string")
+      return chk;
+    var words = [];
+    for (var i = 0;i < wordChars.length; ++i) {
+      var c = wordChars.charAt(i);
+      var v = ALPHABET_MAP[c];
+      if (v === undefined)
+        return "Unknown character " + c;
+      chk = polymodStep(chk) ^ v;
+      if (i + 6 >= wordChars.length)
+        continue;
+      words.push(v);
+    }
+    if (chk !== 1)
+      return "Invalid checksum for " + str;
+    return { prefix, words };
+  }
+  function decodeUnsafe() {
+    var res = __decode.apply(null, arguments);
+    if (typeof res === "object")
+      return res;
+  }
+  function decode(str) {
+    var res = __decode.apply(null, arguments);
+    if (typeof res === "object")
+      return res;
+    throw new Error(res);
+  }
+  function convert(data, inBits, outBits, pad) {
+    var value = 0;
+    var bits = 0;
+    var maxV = (1 << outBits) - 1;
+    var result = [];
+    for (var i = 0;i < data.length; ++i) {
+      value = value << inBits | data[i];
+      bits += inBits;
+      while (bits >= outBits) {
+        bits -= outBits;
+        result.push(value >> bits & maxV);
+      }
+    }
+    if (pad) {
+      if (bits > 0) {
+        result.push(value << outBits - bits & maxV);
+      }
+    } else {
+      if (bits >= inBits)
+        return "Excess padding";
+      if (value << outBits - bits & maxV)
+        return "Non-zero padding";
+    }
+    return result;
+  }
+  function toWordsUnsafe(bytes2) {
+    var res = convert(bytes2, 8, 5, true);
+    if (Array.isArray(res))
+      return res;
+  }
+  function toWords(bytes2) {
+    var res = convert(bytes2, 8, 5, true);
+    if (Array.isArray(res))
+      return res;
+    throw new Error(res);
+  }
+  function fromWordsUnsafe(words) {
+    var res = convert(words, 5, 8, false);
+    if (Array.isArray(res))
+      return res;
+  }
+  function fromWords(words) {
+    var res = convert(words, 5, 8, false);
+    if (Array.isArray(res))
+      return res;
+    throw new Error(res);
+  }
+  var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+  var ALPHABET_MAP = {};
+  for (z = 0;z < ALPHABET.length; z++) {
+    x = ALPHABET.charAt(z);
+    if (ALPHABET_MAP[x] !== undefined)
+      throw new TypeError(x + " is ambiguous");
+    ALPHABET_MAP[x] = z;
+  }
+  var x;
+  var z;
+  module.exports = {
+    decodeUnsafe,
+    decode,
+    encode,
+    toWordsUnsafe,
+    toWords,
+    fromWordsUnsafe,
+    fromWords
+  };
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/bech32.js
+var require_bech324 = __commonJS((exports) => {
+  function toBech32(prefix, data, limit) {
+    const address = bech32.encode(prefix, bech32.toWords(data), limit);
+    return address;
+  }
+  function fromBech32(address, limit = Infinity) {
+    const decodedAddress = bech32.decode(address, limit);
+    return {
+      prefix: decodedAddress.prefix,
+      data: new Uint8Array(bech32.fromWords(decodedAddress.words))
+    };
+  }
+  function normalizeBech32(address) {
+    const { prefix, data } = fromBech32(address);
+    return toBech32(prefix, data);
+  }
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.normalizeBech32 = exports.fromBech32 = exports.toBech32 = undefined;
+  var bech32 = __importStar(require_bech323());
+  exports.toBech32 = toBech32;
+  exports.fromBech32 = fromBech32;
+  exports.normalizeBech32 = normalizeBech32;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/hex.js
+var require_hex2 = __commonJS((exports) => {
+  function toHex(data) {
+    let out = "";
+    for (const byte of data) {
+      out += ("0" + byte.toString(16)).slice(-2);
+    }
+    return out;
+  }
+  function fromHex(hexstring) {
+    if (hexstring.length % 2 !== 0) {
+      throw new Error("hex string length must be a multiple of 2");
+    }
+    const out = new Uint8Array(hexstring.length / 2);
+    for (let i = 0;i < out.length; i++) {
+      const j = 2 * i;
+      const hexByteAsString = hexstring.slice(j, j + 2);
+      if (!hexByteAsString.match(/[0-9a-f]{2}/i)) {
+        throw new Error("hex string contains invalid characters");
+      }
+      out[i] = parseInt(hexByteAsString, 16);
+    }
+    return out;
+  }
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromHex = exports.toHex = undefined;
+  exports.toHex = toHex;
+  exports.fromHex = fromHex;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/rfc3339.js
+var require_rfc33392 = __commonJS((exports) => {
+  function padded(integer, length = 2) {
+    return integer.toString().padStart(length, "0");
+  }
+  function fromRfc3339(str) {
+    const matches = rfc3339Matcher.exec(str);
+    if (!matches) {
+      throw new Error("Date string is not in RFC3339 format");
+    }
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    const hour = +matches[4];
+    const minute = +matches[5];
+    const second = +matches[6];
+    const milliSeconds = matches[7] ? Math.floor(+matches[7] * 1000) : 0;
+    let tzOffsetSign;
+    let tzOffsetHours;
+    let tzOffsetMinutes;
+    if (matches[8] === "Z") {
+      tzOffsetSign = 1;
+      tzOffsetHours = 0;
+      tzOffsetMinutes = 0;
+    } else {
+      tzOffsetSign = matches[8].substring(0, 1) === "-" ? -1 : 1;
+      tzOffsetHours = +matches[8].substring(1, 3);
+      tzOffsetMinutes = +matches[8].substring(4, 6);
+    }
+    const tzOffset = tzOffsetSign * (tzOffsetHours * 60 + tzOffsetMinutes) * 60;
+    const date = new Date;
+    date.setUTCFullYear(year, month - 1, day);
+    date.setUTCHours(hour, minute, second, milliSeconds);
+    return new Date(date.getTime() - tzOffset * 1000);
+  }
+  function toRfc3339(date) {
+    const year = date.getUTCFullYear();
+    const month = padded(date.getUTCMonth() + 1);
+    const day = padded(date.getUTCDate());
+    const hour = padded(date.getUTCHours());
+    const minute = padded(date.getUTCMinutes());
+    const second = padded(date.getUTCSeconds());
+    const ms = padded(date.getUTCMilliseconds(), 3);
+    return `${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}Z`;
+  }
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.toRfc3339 = exports.fromRfc3339 = undefined;
+  var rfc3339Matcher = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(\.\d{1,9})?((?:[+-]\d{2}:\d{2})|Z)$/;
+  exports.fromRfc3339 = fromRfc3339;
+  exports.toRfc3339 = toRfc3339;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/utf8.js
+var require_utf82 = __commonJS((exports) => {
+  function toUtf8(str) {
+    return new TextEncoder().encode(str);
+  }
+  function fromUtf8(data, lossy = false) {
+    const fatal = !lossy;
+    return new TextDecoder("utf-8", { fatal }).decode(data);
+  }
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromUtf8 = exports.toUtf8 = undefined;
+  exports.toUtf8 = toUtf8;
+  exports.fromUtf8 = fromUtf8;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/index.js
+var require_build2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.toUtf8 = exports.fromUtf8 = exports.toRfc3339 = exports.fromRfc3339 = exports.toHex = exports.fromHex = exports.toBech32 = exports.normalizeBech32 = exports.fromBech32 = exports.toBase64 = exports.fromBase64 = exports.toAscii = exports.fromAscii = undefined;
+  var ascii_1 = require_ascii2();
+  Object.defineProperty(exports, "fromAscii", { enumerable: true, get: function() {
+    return ascii_1.fromAscii;
+  } });
+  Object.defineProperty(exports, "toAscii", { enumerable: true, get: function() {
+    return ascii_1.toAscii;
+  } });
+  var base64_1 = require_base642();
+  Object.defineProperty(exports, "fromBase64", { enumerable: true, get: function() {
+    return base64_1.fromBase64;
+  } });
+  Object.defineProperty(exports, "toBase64", { enumerable: true, get: function() {
+    return base64_1.toBase64;
+  } });
+  var bech32_1 = require_bech324();
+  Object.defineProperty(exports, "fromBech32", { enumerable: true, get: function() {
+    return bech32_1.fromBech32;
+  } });
+  Object.defineProperty(exports, "normalizeBech32", { enumerable: true, get: function() {
+    return bech32_1.normalizeBech32;
+  } });
+  Object.defineProperty(exports, "toBech32", { enumerable: true, get: function() {
+    return bech32_1.toBech32;
+  } });
+  var hex_1 = require_hex2();
+  Object.defineProperty(exports, "fromHex", { enumerable: true, get: function() {
+    return hex_1.fromHex;
+  } });
+  Object.defineProperty(exports, "toHex", { enumerable: true, get: function() {
+    return hex_1.toHex;
+  } });
+  var rfc3339_1 = require_rfc33392();
+  Object.defineProperty(exports, "fromRfc3339", { enumerable: true, get: function() {
+    return rfc3339_1.fromRfc3339;
+  } });
+  Object.defineProperty(exports, "toRfc3339", { enumerable: true, get: function() {
+    return rfc3339_1.toRfc3339;
+  } });
+  var utf8_1 = require_utf82();
+  Object.defineProperty(exports, "fromUtf8", { enumerable: true, get: function() {
+    return utf8_1.fromUtf8;
+  } });
+  Object.defineProperty(exports, "toUtf8", { enumerable: true, get: function() {
+    return utf8_1.toUtf8;
+  } });
+});
+
 // ../../node_modules/fast-decode-uri-component/index.js
 var require_fast_decode_uri_component = __commonJS((exports, module) => {
   function decodeURIComponent2(uri) {
@@ -26835,6 +27514,7 @@ import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:f
 import * as fs2 from "node:fs/promises";
 import path from "node:path";
 import { TextDecoder as TextDecoder2 } from "node:util";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../../node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -27911,6 +28591,7 @@ class DoneInstance {
 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);
 var import_backend = __toESM(require_backend(), 1);
 var import_bech32 = __toESM(require_dist(), 1);
 
@@ -28416,7 +29097,7 @@ class DoneLocalChain {
   buildEnv(address, override) {
     const block = {
       height: this.blockHeight,
-      time: this.blockTime.toString(),
+      time: (BigInt(this.blockTime) * 1000000000n).toString(),
       chain_id: this.chainId
     };
     if (override?.block) {
@@ -28441,7 +29122,7 @@ class DoneLocalChain {
     const height = this.blockHeight;
     const blockTime = this.blockTime;
     try {
-      const region = record.vm[entrypoint](env, info, msg);
+      const region = entrypoint === "query" ? record.vm[entrypoint](env, msg) : record.vm[entrypoint](env, info, msg);
       const json = region?.json ?? { err: "contract returned empty response" };
       this.emitContractEvent(record, entrypoint, env, info, json, height, blockTime);
       return json;
@@ -28489,6 +29170,23 @@ class DoneLocalChain {
     view.setUint32(28, this.nextAddressNonce++);
     return import_bech32.bech32.encode(this.bech32Prefix, import_bech32.bech32.toWords(data));
   }
+  restoreStorage(address, entries) {
+    const record = this.contracts.get(address);
+    if (!record) {
+      throw new Error(`contract ${address} not found`);
+    }
+    const storage = record.backend.storage;
+    if (!(storage instanceof import_backend.BasicKVIterStorage)) {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.key || !entry.value)
+        continue;
+      const keyBytes = import_encoding.fromBase64(entry.key);
+      const valueBytes = import_encoding.fromBase64(entry.value);
+      storage.set(keyBytes, valueBytes);
+    }
+  }
 }
 // ../done-local-chain/src/js-contract.ts
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -43271,6 +43969,9 @@ function unwrapQueryResult(result) {
   if (result.err) {
     throw new Error(result.err);
   }
+  if (typeof result.ok === "string") {
+    return decodeData(result.ok);
+  }
   if (result.ok?.data) {
     return decodeData(result.ok.data);
   }
@@ -43772,8 +44473,7 @@ interface SetGreetingBody {
 
 export default Done.serve()
   .instantiate(async () => {
-    const existing = await Greeting.load();
-    if (!existing) {
+    if (!(await Greeting.exists())) {
       await Greeting.save("${defaultGreeting}");
     }
   })
@@ -43912,7 +44612,7 @@ function updateDependencyIfPresent(pkg, name, version) {
 }
 async function syncWorkspaceDependencyVersions(targetDir) {
   await updatePackageJson(path.join(targetDir, "package.json"), (pkg) => {
-    ensureDependency(pkg, "devDependencies", "@donezone/cli", CLI_VERSION_RANGE);
+    ensureDependency(pkg, "devDependencies", "@donezone/cli", CLI_DEPENDENCY_SPEC);
     ensureDependency(pkg, "devDependencies", "done.zone", DONE_ZONE_VERSION_RANGE);
   });
   await updatePackageJson(path.join(targetDir, "frontend", "package.json"), (pkg) => {
@@ -44234,6 +44934,31 @@ async function readDevEnvFile(file2) {
   }
   return entries;
 }
+async function readStorageSnapshot(file2) {
+  try {
+    const raw = await fs2.readFile(file2, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function extractStorageEntries(snapshot) {
+  if (!snapshot?.entries) {
+    return [];
+  }
+  const entries = [];
+  for (const entry of snapshot.entries) {
+    const keyBase64 = entry.key?.base64;
+    const valueBase64 = entry.value?.base64;
+    if (!keyBase64 || !valueBase64)
+      continue;
+    entries.push({ key: keyBase64, value: valueBase64 });
+  }
+  return entries;
+}
 function toEnvVarKey(name) {
   return name.replace(/[^a-zA-Z0-9]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
 }
@@ -44262,6 +44987,7 @@ function openBrowser(url) {
 var packageMetadata = readCliPackageMetadata();
 var CLI_VERSION = normalizeVersion(packageMetadata.version) ?? "0.0.0-spec";
 var CLI_VERSION_RANGE = toCaretRange(CLI_VERSION);
+var CLI_DEPENDENCY_SPEC = process.env.DONE_CLI_LOCAL_SPEC ?? CLI_VERSION_RANGE;
 var DONE_ZONE_VERSION = normalizeVersion(packageMetadata.doneZoneVersion) ?? CLI_VERSION;
 var DONE_ZONE_VERSION_RANGE = toCaretRange(DONE_ZONE_VERSION);
 var DONE_CLIENT_VERSION = normalizeVersion(packageMetadata.doneClientVersion) ?? CLI_VERSION;
@@ -44279,6 +45005,11 @@ if (typeof bunRuntime === "undefined") {
   process.exit(rerun.status ?? 1);
 }
 var DEFAULT_TEMPLATE_REPO = "https://github.com/mccallofthewild/done-template.git";
+var CLI_DIR = path.dirname(fileURLToPath2(import.meta.url));
+var CLI_ARTIFACTS_DIR = path.resolve(CLI_DIR, "..", "artifacts");
+if (!process.env.DONE_ARTIFACTS_DIR && existsSync2(CLI_ARTIFACTS_DIR)) {
+  process.env.DONE_ARTIFACTS_DIR = CLI_ARTIFACTS_DIR;
+}
 var program2 = new Command;
 program2.name("done").description("Done developer toolkit (spec-first stub)").version(CLI_VERSION);
 program2.command("build").description("Bundle Done contracts defined in done.json").option("-j, --contracts <path>", "Path to done.json").option("-n, --name <name...>", "Filter contract names").action(async (options) => {
@@ -44480,9 +45211,13 @@ class DoneDevOrchestrator {
       if (deployment.result.err) {
         throw new Error(`Failed to deploy ${contract.name}: ${deployment.result.err}`);
       }
+      const restored = await this.restoreStorageFromSnapshot(contract, deployment.address);
       contract.address = deployment.address;
       this.chain.advanceBlock();
       this.logInfo(`${import_picocolors.default.green("\u2022")} ${contract.name} deployed at ${deployment.address}`);
+      if (restored) {
+        this.logInfo(`  ${import_picocolors.default.dim("\u21BA state")}: restored snapshot for ${contract.name}`);
+      }
       await this.dumpContractStorage(contract);
     }
   }
@@ -44577,6 +45312,30 @@ class DoneDevOrchestrator {
     const filePath = path.join(storageDir, `${contract.slug}.json`);
     await writeJson(filePath, snapshot);
   }
+  async restoreStorageFromSnapshot(contract, address) {
+    if (!this.chain) {
+      return false;
+    }
+    const filePath = this.resolveStorageSnapshotPath(contract);
+    try {
+      const snapshot = await readStorageSnapshot(filePath);
+      const entries = extractStorageEntries(snapshot);
+      if (entries.length === 0) {
+        return false;
+      }
+      this.chain.restoreStorage(address, entries);
+      return true;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        this.logWarn(`Unable to restore storage for ${contract.name}: ${error.message}`);
+      }
+      return false;
+    }
+  }
+  resolveStorageSnapshotPath(contract) {
+    const storageDir = path.join(this.options.workspace.root, ".done", "storage");
+    return path.join(storageDir, `${contract.slug}.json`);
+  }
   async launchFrontend() {
     const frontend = this.options.devConfig.frontend;
     if (!existsSync2(frontend.cwd)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donezone/cli",
-  "version": "0.1.46",
+  "version": "0.1.49",
   "doneZoneVersion": "0.1.41",
   "doneClientVersion": "0.1.41",
   "private": false,