@donezone/cli 0.1.46 → 0.1.48

package/dist/index.js

@@ -21452,6 +21452,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 +27281,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 +28358,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);
 
@@ -28441,7 +28889,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 +28937,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";
@@ -43080,7 +43545,7 @@ var sharedRouteSchemas = {
 };
 // ../done-http-local/src/server.ts
 async function createDoneHttpLocalServer(config, chain) {
-  const runtime = chain ?? new DoneLocalChain;
+  const runtime = chain ?? loadChainWithArtifacts();
   if (config.scriptPath) {
     await deployJsContract({
       chain: runtime,
@@ -43271,6 +43736,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 +44240,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 +44379,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 +44701,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 +44754,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 +44772,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 +44978,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 +45079,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.48",
   "doneZoneVersion": "0.1.41",
   "doneClientVersion": "0.1.41",
   "private": false,