@gvnrdao/dh-sdk 0.0.209 → 0.0.210

package/dist/index.mjs

@@ -12691,6 +12691,1671 @@ var require_elliptic = __commonJS({
   }
 });
 
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/chunks/pkp-info.i.js
+var require_pkp_info_i = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/chunks/pkp-info.i.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/chunks/lit-action-config.i.js
+var require_lit_action_config_i = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/chunks/lit-action-config.i.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/chunks/diamond-hands-lit-actions.i.js
+var require_diamond_hands_lit_actions_i = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/chunks/diamond-hands-lit-actions.i.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/chunks/lit-action-registry.i.js
+var require_lit_action_registry_i = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/chunks/lit-action-registry.i.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/index.js
+var require_interfaces = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/interfaces/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        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 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_pkp_info_i(), exports);
+    __exportStar(require_lit_action_config_i(), exports);
+    __exportStar(require_diamond_hands_lit_actions_i(), exports);
+    __exportStar(require_lit_action_registry_i(), exports);
+  }
+});
+
+// node_modules/base-x/src/cjs/index.cjs
+var require_cjs = __commonJS({
+  "node_modules/base-x/src/cjs/index.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function base2(ALPHABET) {
+      if (ALPHABET.length >= 255) {
+        throw new TypeError("Alphabet too long");
+      }
+      const BASE_MAP = new Uint8Array(256);
+      for (let j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+      }
+      for (let i = 0; i < ALPHABET.length; i++) {
+        const x = ALPHABET.charAt(i);
+        const xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+          throw new TypeError(x + " is ambiguous");
+        }
+        BASE_MAP[xc] = i;
+      }
+      const BASE = ALPHABET.length;
+      const LEADER = ALPHABET.charAt(0);
+      const FACTOR = Math.log(BASE) / Math.log(256);
+      const iFACTOR = Math.log(256) / Math.log(BASE);
+      function encode4(source) {
+        if (source instanceof Uint8Array) {
+        } else if (ArrayBuffer.isView(source)) {
+          source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        } else if (Array.isArray(source)) {
+          source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+          throw new TypeError("Expected Uint8Array");
+        }
+        if (source.length === 0) {
+          return "";
+        }
+        let zeroes = 0;
+        let length = 0;
+        let pbegin = 0;
+        const pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+          pbegin++;
+          zeroes++;
+        }
+        const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+        const b58 = new Uint8Array(size);
+        while (pbegin !== pend) {
+          let carry = source[pbegin];
+          let i = 0;
+          for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+            carry += 256 * b58[it1] >>> 0;
+            b58[it1] = carry % BASE >>> 0;
+            carry = carry / BASE >>> 0;
+          }
+          if (carry !== 0) {
+            throw new Error("Non-zero carry");
+          }
+          length = i;
+          pbegin++;
+        }
+        let it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+          it2++;
+        }
+        let str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+          str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+      }
+      function decodeUnsafe(source) {
+        if (typeof source !== "string") {
+          throw new TypeError("Expected String");
+        }
+        if (source.length === 0) {
+          return new Uint8Array();
+        }
+        let psz = 0;
+        let zeroes = 0;
+        let length = 0;
+        while (source[psz] === LEADER) {
+          zeroes++;
+          psz++;
+        }
+        const size = (source.length - psz) * FACTOR + 1 >>> 0;
+        const b256 = new Uint8Array(size);
+        while (psz < source.length) {
+          const charCode = source.charCodeAt(psz);
+          if (charCode > 255) {
+            return;
+          }
+          let carry = BASE_MAP[charCode];
+          if (carry === 255) {
+            return;
+          }
+          let i = 0;
+          for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+            carry += BASE * b256[it3] >>> 0;
+            b256[it3] = carry % 256 >>> 0;
+            carry = carry / 256 >>> 0;
+          }
+          if (carry !== 0) {
+            throw new Error("Non-zero carry");
+          }
+          length = i;
+          psz++;
+        }
+        let it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+          it4++;
+        }
+        const vch = new Uint8Array(zeroes + (size - it4));
+        let j = zeroes;
+        while (it4 !== size) {
+          vch[j++] = b256[it4++];
+        }
+        return vch;
+      }
+      function decode3(string) {
+        const buffer = decodeUnsafe(string);
+        if (buffer) {
+          return buffer;
+        }
+        throw new Error("Non-base" + BASE + " character");
+      }
+      return {
+        encode: encode4,
+        decodeUnsafe,
+        decode: decode3
+      };
+    }
+    exports.default = base2;
+  }
+});
+
+// node_modules/bs58/src/cjs/index.cjs
+var require_cjs2 = __commonJS({
+  "node_modules/bs58/src/cjs/index.cjs"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var base_x_1 = __importDefault(require_cjs());
+    var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    exports.default = (0, base_x_1.default)(ALPHABET);
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/cid-utils.js
+var require_cid_utils = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/cid-utils.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.cidToHex = cidToHex;
+    var bs58_1 = __importDefault(require_cjs2());
+    function cidToHex(cid) {
+      try {
+        if (cid.startsWith("Qm")) {
+          const bytes = bs58_1.default.decode(cid);
+          return "0x" + Buffer.from(bytes).toString("hex");
+        } else if (cid.startsWith("0x")) {
+          return cid;
+        } else {
+          throw new Error(`Unsupported CID format: ${cid}. Only CIDv0 (Qm...) and hex (0x...) formats are supported.`);
+        }
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Unsupported CID format")) {
+          throw error;
+        }
+        throw new Error(`Failed to convert CID ${cid} to hex: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/constants/chunks/lit-actions-registry.js
+var require_lit_actions_registry = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/constants/chunks/lit-actions-registry.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CHIPOTLE_DEPLOYMENTS = exports.DH_LIT_ACTIONS_CHIPOTLE = void 0;
+    exports.getDeploymentsForNetwork = getDeploymentsForNetwork;
+    var cid_utils_1 = require_cid_utils();
+    exports.DH_LIT_ACTIONS_CHIPOTLE = {
+      authorizationDummy: {
+        cid: "QmXPh5RTReLqjqZDRNhgVKi1TWMJK2vS9QSRPkWPhLBQJN",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmXPh5RTReLqjqZDRNhgVKi1TWMJK2vS9QSRPkWPhLBQJN"),
+        name: "Authorization Dummy",
+        description: "Production Authorization Dummy",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776707622939,
+        size: 2026,
+        hash: "349d51aa096d56b394f82de75ed34cd4eef72719969f7e5fe584f4582b2745fa"
+      },
+      authorizationDummyB: {
+        cid: "QmQXTcAU9tr4YAVrzHujEJw9moJgM1o5gnJU2ojcvhigua",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmQXTcAU9tr4YAVrzHujEJw9moJgM1o5gnJU2ojcvhigua"),
+        name: "Authorization Dummy B",
+        description: "Production Authorization Dummy B",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776707632987,
+        size: 1695,
+        hash: "def4576ba6c382d145f996c4f950b5e39e58792415ee7fdd749e0d2bc61e8f0b"
+      },
+      pkpValidator: {
+        cid: "QmSo9fkRJA5rS2AnkpKyFgE7ADdGRC2mXvcXVUPaSBRxv1",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmSo9fkRJA5rS2AnkpKyFgE7ADdGRC2mXvcXVUPaSBRxv1"),
+        name: "Pkp Validator",
+        description: "Production Pkp Validator",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776315028869,
+        size: 4030,
+        hash: "f57523311d2f1f1f1fae5a1bbdcd877582e64268c1cb90396c0d1dc26ab9a1fb",
+        validatorWalletAddress: "0x9ee56687f7a984d5df7ab79330271a619ef56ddd",
+        pkp: {
+          publicKey: "0x04ec0e3acc40884e3f366ca469d08899eb640ad5259fa196b0238075086208a9f8732a3175704f35f0bcc28e07406cfb24c254efd1e7355640577330f0d2dd755f",
+          ethAddress: "0x9eE56687F7a984D5DF7aB79330271a619ef56DdD"
+        }
+      },
+      btcTransactionSigner: {
+        cid: "QmYSvuDcn2EPjRoDsPBLK2e3PGYEUHtWAPxwB51s4unkaG",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmYSvuDcn2EPjRoDsPBLK2e3PGYEUHtWAPxwB51s4unkaG"),
+        name: "Btc Transaction Signer",
+        description: "Production Btc Transaction Signer",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776767100453,
+        size: 25657,
+        hash: "422311d10447a806bf435a1df440ff00d4eee986c019ccdb4af15bdbfd8019cf"
+      },
+      ucdMintValidator: {
+        cid: "QmRrL2oTyEyAsTNQQDbq7LpMtU6EJJCbmnLGKGJM4ULr1h",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmRrL2oTyEyAsTNQQDbq7LpMtU6EJJCbmnLGKGJM4ULr1h"),
+        name: "Ucd Mint Validator",
+        description: "Production Ucd Mint Validator",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776782297891,
+        size: 64983,
+        hash: "001bbe2c2ba746daf2a29653c053fbe3ac84312df45dada048e18947fa3cc05b",
+        validatorWalletAddress: "0x36f3dd61c4c08a56d29ed2fd6d5f111b67b6a7a1",
+        pkp: {
+          publicKey: "0x041ab17cd91fc5c0b761eea6092d032807561b621b82c488826776e04a9158d61ba64d809a4729f0501289d980732cb06d8dfd06999dd9c8efd2f495dad78b31bb",
+          ethAddress: "0x4D9299055093938d0CD2F26C42A87260CB50adD8"
+        }
+      },
+      processPaymentValidator: {
+        cid: "QmR7rT7iG74YeSVoavTSTgBtZqcmCKG3Tf3hmzQ3zTFUb3",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmR7rT7iG74YeSVoavTSTgBtZqcmCKG3Tf3hmzQ3zTFUb3"),
+        name: "Process Payment Validator",
+        description: "Production Process Payment Validator",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776782306970,
+        size: 60889,
+        hash: "2153e187d2bbd713d41a87d1dac2199ab879590761becf55c708e5fb970bf941",
+        validatorWalletAddress: "0xc2ed5a59bd81eb4d1a19a0147b86ab69aa4c28ba",
+        pkp: {
+          publicKey: "0x04cfccb9b6c7addc79469c0e9fafebef4c70801302c62cdb26b610723a9b8527d23f98a40158c7340d83fd0e62d02b5ec74c12f7a86d98e8c6973b4811110f19ad",
+          ethAddress: "0x440Fd7B157766b95eb551825C06DF4f92E41D55b"
+        }
+      },
+      extendPositionValidator: {
+        cid: "QmZGWWnjVcfHzSBQzgXfMmxQJUYXKt9jsCXrCPZXzuPxPv",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmZGWWnjVcfHzSBQzgXfMmxQJUYXKt9jsCXrCPZXzuPxPv"),
+        name: "Extend Position Validator",
+        description: "Production Extend Position Validator",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776782316021,
+        size: 60346,
+        hash: "630dacf25495e39a4011c5e28a74a5d9f09e9b89eb0d701868e8881e28609269",
+        validatorWalletAddress: "0xb3f4271c475887a86a2f21446f0968c30cc74c97",
+        pkp: {
+          publicKey: "0x04e52338f6a0c3362800f1a94c4c8f08be5030dde0fa217388c53d1c1a4790f4443c9f2886b2d2d8f4b75a9a156e9b028011b1a1cf7648da0e556aa980ec692836",
+          ethAddress: "0x4cb7651Ba27610991A5775486B5F4487F3Dd7cDA"
+        }
+      },
+      btcWithdrawal: {
+        cid: "QmX9HxZsogBTBSurQPnopMtGDQRXtd3HynHxkqgq23u3rm",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmX9HxZsogBTBSurQPnopMtGDQRXtd3HynHxkqgq23u3rm"),
+        name: "Btc Withdrawal",
+        description: "Production Btc Withdrawal",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776782325228,
+        size: 69488,
+        hash: "361055707df1851003f867635bb8c29eaaef6ced2e57c9d0250b8739d01e6b13",
+        validatorWalletAddress: "0xbb137fbda353199e9419b698c57a742124d4987d",
+        pkp: {
+          publicKey: "0x043616787c5432415c24378c4ef48de2bcd6bb7b575b837e3cff09171802662da7105d79586c7659677a0ecbaddac4cce06cb2a11f69a16fa0c4d7002ac7d51a4d",
+          ethAddress: "0x7b9316cAA00B257F7CE30F7F6979bd6867BA9eE2"
+        }
+      },
+      liquidationValidator: {
+        cid: "QmbufZa57vL7k3eeeFs9vy6LPry5XMYjJrYw7wCHzc3TWH",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmbufZa57vL7k3eeeFs9vy6LPry5XMYjJrYw7wCHzc3TWH"),
+        name: "Liquidation Validator",
+        description: "Production Liquidation Validator",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776782332379,
+        size: 54383,
+        hash: "a2acf645716ed249b62ecc2069609eb53b17fe60c41d3027f0c3e98c3bffb4ca",
+        validatorWalletAddress: "0x1542f863ee0340f6a067573e80ae66dd9b3838fa",
+        pkp: {
+          publicKey: "0x041a241de58976c13e3d7ca5a18e494f7330151e3818706135d50176e78ffb673e58b11f0b67a87c73fade6c6b27d6e7a7377ea9f4c10bf31880f1d725f18cc6f8",
+          ethAddress: "0x8770470620Db25bBf2BFBca1eF7Bdd6CF91ab1b5"
+        }
+      },
+      priceOracle: {
+        cid: "QmXKfK7JJFixFPvm48uwgVVW7s3eoE3sEyFEbZZ3dfNK1e",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmXKfK7JJFixFPvm48uwgVVW7s3eoE3sEyFEbZZ3dfNK1e"),
+        name: "Price Oracle",
+        description: "Production Price Oracle (Chipotle main+getPrivateKey)",
+        version: "1.1.0",
+        deployed: true,
+        deployedAt: 1776708126597,
+        size: 11644,
+        hash: "d175d8571aa4337d465115f9939a2d72965255c7c7a64c33e546ffff141e7a09",
+        validatorWalletAddress: "0x831ddf3048547b983efe3ccbbb35a45a53191651",
+        pkp: {
+          publicKey: "0x043beaa1da47875601a8d6f430b1438ee2d4732eefd06e5c63a474bbdaf9e7df1797b1b951e041b627c2bf839788164825324c9cbd1e2d6f740fdd4bff69b1900b",
+          ethAddress: "0x831DdF3048547B983EFE3ccBBB35a45a53191651"
+        }
+      },
+      loanVaultBtcBalance: {
+        cid: "QmUdw25GDYMY6gm7nChBxpHtkwtoSEMjf66QWJ1dCikWkt",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmUdw25GDYMY6gm7nChBxpHtkwtoSEMjf66QWJ1dCikWkt"),
+        name: "Loan Vault Btc Balance",
+        description: "Production Loan Vault Btc Balance",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776782341246,
+        size: 43769,
+        hash: "780ea6731fa48e0b15e1666ab1c6aa91471dbf748d36fa1e93f74614047bacb7",
+        validatorWalletAddress: "0x47feea74c8739d24b44faa67217f2f99970e15e7",
+        pkp: {
+          publicKey: "0x043616787c5432415c24378c4ef48de2bcd6bb7b575b837e3cff09171802662da7105d79586c7659677a0ecbaddac4cce06cb2a11f69a16fa0c4d7002ac7d51a4d",
+          ethAddress: "0x7b9316cAA00B257F7CE30F7F6979bd6867BA9eE2"
+        }
+      },
+      adminLiquidationValidator: {
+        cid: "QmYBpkLWKZbEBgdZnfFMabszmPYQJsfdVsqwVyJqdrMnP4",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmYBpkLWKZbEBgdZnfFMabszmPYQJsfdVsqwVyJqdrMnP4"),
+        name: "Admin Liquidation Validator",
+        description: "Production Admin Liquidation Validator",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776782348498,
+        size: 51032,
+        hash: "b3af59aab3d71841e2b06e11da7c1664e451e636ead6ee746604be82ff472a13",
+        validatorWalletAddress: "0x2a83b78842d75358877deb8854ccc5bbbaa5012e",
+        pkp: {
+          publicKey: "0x04ee4316afb8538280ede6c56def9cbe791f18f96ccba97768b28e2966d9c46a9493a6b81f4571495c3ce56c2d0b33fe8cf63726cd12d395832ea54162b5c67801",
+          ethAddress: "0x038B7a1918ae9121bC641236b7946a069BE21591"
+        }
+      },
+      alwaysSigner: {
+        cid: "QmXQjybSsdE19Da66to9Hh7X2dLFwpZPhjoqojxbpk7Nvs",
+        authorizedCidHex: (0, cid_utils_1.cidToHex)("QmXQjybSsdE19Da66to9Hh7X2dLFwpZPhjoqojxbpk7Nvs"),
+        name: "Always Signer",
+        description: "Production Always Signer",
+        version: "1.0.0",
+        deployed: true,
+        deployedAt: 1776708176283,
+        size: 4143,
+        hash: "25007f80b4ed3169470bf617d403971136be431eb29dfb09f78afe2494bf0138"
+      }
+    };
+    function getDeploymentsForNetwork(network) {
+      if (network === "chipotle")
+        return exports.DH_LIT_ACTIONS_CHIPOTLE;
+      throw new Error(`Unsupported LIT network: ${network}`);
+    }
+    exports.CHIPOTLE_DEPLOYMENTS = exports.DH_LIT_ACTIONS_CHIPOTLE;
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/lit-action-helpers.js
+var require_lit_action_helpers = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/lit-action-helpers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getLitActionCID = getLitActionCID;
+    exports.getLitActionConfig = getLitActionConfig;
+    exports.isLitActionDeployed = isLitActionDeployed;
+    exports.validateDeployedActions = validateDeployedActions;
+    exports.getDeployedActions = getDeployedActions;
+    var lit_actions_registry_1 = require_lit_actions_registry();
+    function getLitActionCID(litNetwork = "chipotle", actionName) {
+      const deployments = (0, lit_actions_registry_1.getDeploymentsForNetwork)(litNetwork);
+      const action = deployments[actionName];
+      if (!action || !action.deployed || !action.cid) {
+        throw new Error(`LIT Action '${actionName}' not deployed on network '${litNetwork}'. Check deployment status.`);
+      }
+      return action.cid;
+    }
+    function getLitActionConfig(actionName, litNetwork = "chipotle") {
+      const deployments = (0, lit_actions_registry_1.getDeploymentsForNetwork)(litNetwork);
+      const action = deployments[actionName];
+      if (!action) {
+        throw new Error(`LIT Action '${actionName}' not found in registry for network '${litNetwork}'.`);
+      }
+      return action;
+    }
+    function isLitActionDeployed(actionName, litNetwork = "chipotle") {
+      const deployments = (0, lit_actions_registry_1.getDeploymentsForNetwork)(litNetwork);
+      const action = deployments[actionName];
+      return !!(action && action.deployed && action.cid);
+    }
+    function validateDeployedActions(requiredActions, litNetwork = "chipotle") {
+      return requiredActions.every((actionName) => isLitActionDeployed(actionName, litNetwork));
+    }
+    function getDeployedActions(litNetwork = "chipotle") {
+      const deployments = (0, lit_actions_registry_1.getDeploymentsForNetwork)(litNetwork);
+      return Object.values(deployments).filter((action) => action && action.deployed);
+    }
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/pkp-setup.js
+var require_pkp_setup = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/pkp-setup.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getPKPValidatorSetup = getPKPValidatorSetup;
+    var lit_actions_registry_1 = require_lit_actions_registry();
+    function getPKPValidatorSetup(litNetwork = "chipotle") {
+      const deployments = (0, lit_actions_registry_1.getDeploymentsForNetwork)(litNetwork);
+      const litAction = deployments.pkpValidator;
+      if (!litAction || !litAction.pkp) {
+        throw new Error(`PKP validator setup is not available for litNetwork='${litNetwork}'. Ensure the pkpValidator action (with pkp attached) is defined in the registry.`);
+      }
+      return {
+        litAction,
+        pkp: litAction.pkp
+      };
+    }
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/debug-logger.js
+var require_debug_logger = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/debug-logger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.networkMetrics = exports.PerformanceTracker = exports.DEFAULT_DEBUG_CONFIG = exports.LogLevel = void 0;
+    exports.configureDebugLogging = configureDebugLogging;
+    exports.debugError = debugError;
+    exports.debugWarn = debugWarn;
+    exports.debugInfo = debugInfo;
+    exports.debugLog = debugLog;
+    exports.debugTrace = debugTrace;
+    exports.logRequest = logRequest;
+    exports.logResponse = logResponse;
+    exports.logError = logError;
+    exports.logConnectionAttempt = logConnectionAttempt;
+    exports.logConnectionSuccess = logConnectionSuccess;
+    exports.logConnectionFailure = logConnectionFailure;
+    exports.logPkpOperation = logPkpOperation;
+    exports.logSessionSignatures = logSessionSignatures;
+    exports.logLitActionExecution = logLitActionExecution;
+    exports.logLitActionResult = logLitActionResult;
+    exports.logTestStart = logTestStart;
+    exports.logTestEnd = logTestEnd;
+    var LogLevel2;
+    (function(LogLevel3) {
+      LogLevel3[LogLevel3["ERROR"] = 0] = "ERROR";
+      LogLevel3[LogLevel3["WARN"] = 1] = "WARN";
+      LogLevel3[LogLevel3["INFO"] = 2] = "INFO";
+      LogLevel3[LogLevel3["DEBUG"] = 3] = "DEBUG";
+      LogLevel3[LogLevel3["TRACE"] = 4] = "TRACE";
+    })(LogLevel2 || (exports.LogLevel = LogLevel2 = {}));
+    exports.DEFAULT_DEBUG_CONFIG = {
+      level: LogLevel2.INFO,
+      enableTimestamps: true,
+      enablePerformanceMetrics: true,
+      enableRequestLogging: true,
+      enableNetworkMetrics: true
+    };
+    var debugConfig = { ...exports.DEFAULT_DEBUG_CONFIG };
+    function configureDebugLogging(config) {
+      debugConfig = { ...debugConfig, ...config };
+    }
+    function getTimestamp() {
+      return (/* @__PURE__ */ new Date()).toISOString();
+    }
+    function formatMessage(level, component, message, metadata) {
+      const timestamp = debugConfig.enableTimestamps ? `[${getTimestamp()}] ` : "";
+      const metadataStr = metadata ? ` ${JSON.stringify(metadata)}` : "";
+      return `${timestamp}[${level}] [${component}] ${message}${metadataStr}`;
+    }
+    var PerformanceTracker = class {
+      constructor(operationName) {
+        this.operationName = operationName;
+        this.markers = /* @__PURE__ */ new Map();
+        this.startTime = Date.now();
+        this.log("PERF", `Started: ${operationName}`);
+      }
+      mark(label) {
+        const elapsed = Date.now() - this.startTime;
+        this.markers.set(label, elapsed);
+        this.log("PERF", `${this.operationName} - ${label}: ${elapsed}ms`);
+      }
+      end(success2 = true) {
+        const totalTime = Date.now() - this.startTime;
+        const status = success2 ? "SUCCESS" : "FAILED";
+        this.log("PERF", `${this.operationName} - ${status}: ${totalTime}ms`);
+        if (debugConfig.enablePerformanceMetrics && this.markers.size > 0) {
+          console.log(`\u{1F4CA} Performance Breakdown for ${this.operationName}:`);
+          for (const [label, time] of this.markers) {
+            console.log(`   ${label}: ${time}ms`);
+          }
+          console.log(`   Total: ${totalTime}ms`);
+        }
+        return totalTime;
+      }
+      log(level, message) {
+        if (debugConfig.enablePerformanceMetrics) {
+          console.log(formatMessage(level, "PERFORMANCE", message));
+        }
+      }
+    };
+    exports.PerformanceTracker = PerformanceTracker;
+    var NetworkMetricsCollector = class {
+      constructor() {
+        this.metrics = /* @__PURE__ */ new Map();
+      }
+      getMetrics(operation) {
+        if (!this.metrics.has(operation)) {
+          this.metrics.set(operation, {
+            requestCount: 0,
+            successCount: 0,
+            failureCount: 0,
+            averageLatency: 0,
+            startTime: Date.now()
+          });
+        }
+        return this.metrics.get(operation);
+      }
+      recordRequest(operation, success2, latency, error) {
+        const metrics = this.getMetrics(operation);
+        metrics.requestCount++;
+        if (success2) {
+          metrics.successCount++;
+          metrics.averageLatency = (metrics.averageLatency * (metrics.successCount - 1) + latency) / metrics.successCount;
+        } else {
+          metrics.failureCount++;
+          if (error)
+            metrics.lastError = error;
+        }
+        if (debugConfig.enableNetworkMetrics) {
+          const successRate = (metrics.successCount / metrics.requestCount * 100).toFixed(1);
+          debugLog("NETWORK", `${operation} - Success: ${success2}, Latency: ${latency}ms, Success Rate: ${successRate}%`);
+        }
+      }
+      printSummary() {
+        if (!debugConfig.enableNetworkMetrics)
+          return;
+        console.log("\n\u{1F4C8} Network Metrics Summary:");
+        for (const [operation, metrics] of this.metrics) {
+          const successRate = (metrics.successCount / metrics.requestCount * 100).toFixed(1);
+          const runtime = Date.now() - metrics.startTime;
+          console.log(`   ${operation}:`);
+          console.log(`     Requests: ${metrics.requestCount}`);
+          console.log(`     Success Rate: ${successRate}%`);
+          console.log(`     Avg Latency: ${metrics.averageLatency.toFixed(0)}ms`);
+          console.log(`     Runtime: ${runtime}ms`);
+          if (metrics.lastError) {
+            console.log(`     Last Error: ${metrics.lastError}`);
+          }
+        }
+      }
+    };
+    exports.networkMetrics = new NetworkMetricsCollector();
+    function debugError(component, message, metadata) {
+      if (debugConfig.level >= LogLevel2.ERROR) {
+        console.error(formatMessage("ERROR", component, message, metadata));
+      }
+    }
+    function debugWarn(component, message, metadata) {
+      if (debugConfig.level >= LogLevel2.WARN) {
+        console.warn(formatMessage("WARN", component, message, metadata));
+      }
+    }
+    function debugInfo(component, message, metadata) {
+      if (debugConfig.level >= LogLevel2.INFO) {
+        console.log(formatMessage("INFO", component, message, metadata));
+      }
+    }
+    function debugLog(component, message, metadata) {
+      if (debugConfig.level >= LogLevel2.DEBUG) {
+        console.log(formatMessage("DEBUG", component, message, metadata));
+      }
+    }
+    function debugTrace(component, message, metadata) {
+      if (debugConfig.level >= LogLevel2.TRACE) {
+        console.log(formatMessage("TRACE", component, message, metadata));
+      }
+    }
+    function logRequest(component, operation, params) {
+      if (!debugConfig.enableRequestLogging)
+        return;
+      debugLog(component, `\u{1F504} Request: ${operation}`, {
+        operation,
+        params: JSON.stringify(params, null, 2)
+      });
+    }
+    function logResponse(component, operation, response, duration) {
+      if (!debugConfig.enableRequestLogging)
+        return;
+      debugLog(component, `\u2705 Response: ${operation} (${duration}ms)`, {
+        operation,
+        duration,
+        response: typeof response === "object" ? JSON.stringify(response, null, 2) : response
+      });
+    }
+    function logError(component, operation, error, duration) {
+      const durationStr = duration ? ` (${duration}ms)` : "";
+      debugError(component, `\u274C Error: ${operation}${durationStr}`, {
+        operation,
+        duration,
+        error: error?.message || error?.toString() || "Unknown error",
+        stack: error?.stack
+      });
+    }
+    function logConnectionAttempt(network, attempt, maxAttempts) {
+      debugInfo("CONNECTION", `\u{1F517} Connecting to ${network} (attempt ${attempt}/${maxAttempts})`);
+    }
+    function logConnectionSuccess(network, latency) {
+      debugInfo("CONNECTION", `\u2705 Connected to ${network} (${latency}ms)`);
+      exports.networkMetrics.recordRequest(`connection-${network}`, true, latency);
+    }
+    function logConnectionFailure(network, error, attempt) {
+      debugError("CONNECTION", `\u274C Connection failed to ${network} (attempt ${attempt})`, { error });
+      exports.networkMetrics.recordRequest(`connection-${network}`, false, 0, error);
+    }
+    function logPkpOperation(operation, pkpId, details) {
+      const pkpStr = pkpId ? ` (PKP: ${pkpId.slice(0, 8)}...)` : "";
+      debugInfo("PKP", `\u{1F511} ${operation}${pkpStr}`, details);
+    }
+    function logSessionSignatures(count, expiration) {
+      debugInfo("SESSION", `\u{1F510} Generated ${count} session signatures (expires: ${expiration})`);
+    }
+    function logLitActionExecution(cid, params) {
+      debugInfo("LIT_ACTION", `\u26A1 Executing LIT Action: ${cid}`, {
+        cid,
+        params
+      });
+    }
+    function logLitActionResult(cid, success2, duration, result) {
+      const status = success2 ? "\u2705" : "\u274C";
+      debugInfo("LIT_ACTION", `${status} LIT Action completed: ${cid} (${duration}ms)`, {
+        cid,
+        success: success2,
+        duration,
+        result: success2 && result ? JSON.stringify(result, null, 2) : void 0
+      });
+    }
+    function logTestStart(testName) {
+      debugInfo("TEST", `\u{1F9EA} Starting test: ${testName}`);
+      return new PerformanceTracker(testName);
+    }
+    function logTestEnd(testName, success2, duration) {
+      const status = success2 ? "\u2705" : "\u274C";
+      debugInfo("TEST", `${status} Test completed: ${testName} (${duration}ms)`);
+      exports.networkMetrics.printSummary();
+    }
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/error-classification.js
+var require_error_classification = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/error-classification.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.litProtocolErrors = exports.RetryStrategy = exports.ErrorCategory = void 0;
+    exports.classifyError = classifyError;
+    exports.getRetryConfigFromClassification = getRetryConfigFromClassification;
+    exports.analyzeError = analyzeError;
+    exports.createErrorReport = createErrorReport;
+    var ErrorCategory2;
+    (function(ErrorCategory3) {
+      ErrorCategory3["NETWORK"] = "network";
+      ErrorCategory3["PROTOCOL"] = "protocol";
+      ErrorCategory3["AUTHENTICATION"] = "authentication";
+      ErrorCategory3["RESOURCE"] = "resource";
+      ErrorCategory3["VALIDATION"] = "validation";
+      ErrorCategory3["TIMEOUT"] = "timeout";
+      ErrorCategory3["RATE_LIMIT"] = "rate_limit";
+      ErrorCategory3["CONFIGURATION"] = "configuration";
+      ErrorCategory3["UNKNOWN"] = "unknown";
+    })(ErrorCategory2 || (exports.ErrorCategory = ErrorCategory2 = {}));
+    var RetryStrategy;
+    (function(RetryStrategy2) {
+      RetryStrategy2["AGGRESSIVE"] = "aggressive";
+      RetryStrategy2["CONSERVATIVE"] = "conservative";
+      RetryStrategy2["EXPONENTIAL"] = "exponential";
+      RetryStrategy2["LINEAR"] = "linear";
+      RetryStrategy2["NONE"] = "none";
+    })(RetryStrategy || (exports.RetryStrategy = RetryStrategy = {}));
+    var LIT_ERROR_PATTERNS = {
+      // Network and connection errors
+      network: [
+        /network error/i,
+        /connection failed/i,
+        /connection refused/i,
+        /connection timeout/i,
+        /socket hang up/i,
+        /enotfound/i,
+        /econnrefused/i,
+        /etimedout/i,
+        /dns resolution failed/i,
+        /request failed/i
+      ],
+      // Protocol specific errors
+      protocol: [
+        /lit protocol/i,
+        /lit node/i,
+        /signing shares/i,
+        /node communication/i,
+        /consensus/i,
+        /threshold/i,
+        /decryption/i,
+        /signature verification/i,
+        /There was an error getting the signing shares/i,
+        /Response from the nodes/i,
+        /NodeError/i,
+        /PKP validation/i,
+        /pkp validation failed/i
+      ],
+      // Authentication and authorization errors
+      authentication: [
+        /authentication/i,
+        /authorization/i,
+        /session.*expired/i,
+        /invalid.*signature/i,
+        /unauthorized/i,
+        /access.*denied/i,
+        /permission/i,
+        /auth.*failed/i,
+        /siwe/i,
+        /session.*sig/i
+      ],
+      // Resource and validation errors
+      resource: [
+        /resource.*not.*found/i,
+        /ipfs.*not.*found/i,
+        /cid.*invalid/i,
+        /pkp.*not.*found/i,
+        /pkp.*validation/i,
+        /resource.*validation/i,
+        /action.*not.*permitted/i,
+        /lit.*action.*not.*found/i
+      ],
+      // Validation errors
+      validation: [
+        /validation.*failed/i,
+        /invalid.*input/i,
+        /invalid.*parameter/i,
+        /malformed/i,
+        /schema.*validation/i,
+        /type.*error/i,
+        /missing.*required/i
+      ],
+      // Timeout specific errors
+      timeout: [
+        /timeout/i,
+        /request.*timed.*out/i,
+        /operation.*timed.*out/i,
+        /deadline.*exceeded/i,
+        /time.*limit.*exceeded/i
+      ],
+      // Rate limiting errors
+      rateLimit: [
+        /rate.*limit/i,
+        /too.*many.*requests/i,
+        /quota.*exceeded/i,
+        /throttled/i,
+        /429/,
+        /rate.*exceeded/i
+      ],
+      // Configuration errors
+      configuration: [
+        /configuration/i,
+        /config.*error/i,
+        /environment/i,
+        /missing.*env/i,
+        /invalid.*config/i,
+        /setup.*error/i
+      ]
+    };
+    var RETRY_STRATEGIES = {
+      [RetryStrategy.AGGRESSIVE]: {
+        maxAttempts: 5,
+        baseDelayMs: 500,
+        maxDelayMs: 5e3,
+        multiplier: 1.5
+      },
+      [RetryStrategy.CONSERVATIVE]: {
+        maxAttempts: 3,
+        baseDelayMs: 3e3,
+        maxDelayMs: 3e4,
+        multiplier: 2.5
+      },
+      [RetryStrategy.EXPONENTIAL]: {
+        maxAttempts: 4,
+        baseDelayMs: 1e3,
+        maxDelayMs: 15e3,
+        multiplier: 2
+      },
+      [RetryStrategy.LINEAR]: {
+        maxAttempts: 3,
+        baseDelayMs: 2e3,
+        maxDelayMs: 1e4,
+        multiplier: 1
+      },
+      [RetryStrategy.NONE]: {
+        maxAttempts: 1,
+        baseDelayMs: 0,
+        maxDelayMs: 0,
+        multiplier: 1
+      }
+    };
+    var CLASSIFICATION_RULES = {
+      [ErrorCategory2.NETWORK]: {
+        category: ErrorCategory2.NETWORK,
+        retryStrategy: RetryStrategy.AGGRESSIVE,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.AGGRESSIVE],
+        description: "Network connectivity or communication error",
+        troubleshooting: [
+          "Check internet connection",
+          "Verify LIT Protocol network status",
+          "Check firewall and proxy settings",
+          "Try connecting to different node endpoints"
+        ]
+      },
+      [ErrorCategory2.PROTOCOL]: {
+        category: ErrorCategory2.PROTOCOL,
+        retryStrategy: RetryStrategy.CONSERVATIVE,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.CONSERVATIVE],
+        description: "LIT Protocol specific operational error",
+        troubleshooting: [
+          "Check LIT Protocol network status",
+          "Verify PKP configuration",
+          "Check signing shares availability",
+          "Wait for network consensus"
+        ]
+      },
+      [ErrorCategory2.AUTHENTICATION]: {
+        category: ErrorCategory2.AUTHENTICATION,
+        retryStrategy: RetryStrategy.EXPONENTIAL,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.EXPONENTIAL],
+        maxAttempts: 2,
+        // Override: limited retries for auth issues
+        description: "Authentication or authorization error",
+        troubleshooting: [
+          "Check session signatures validity",
+          "Regenerate authentication tokens",
+          "Verify wallet permissions",
+          "Check PKP authorization status"
+        ]
+      },
+      [ErrorCategory2.RESOURCE]: {
+        category: ErrorCategory2.RESOURCE,
+        retryStrategy: RetryStrategy.LINEAR,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.LINEAR],
+        maxAttempts: 2,
+        // Override: limited retries for resource issues
+        description: "Resource not found or validation error",
+        troubleshooting: [
+          "Verify resource CIDs are correct",
+          "Check IPFS availability",
+          "Confirm PKP exists and is accessible",
+          "Wait for resource propagation"
+        ]
+      },
+      [ErrorCategory2.VALIDATION]: {
+        category: ErrorCategory2.VALIDATION,
+        retryStrategy: RetryStrategy.NONE,
+        isRetryable: false,
+        ...RETRY_STRATEGIES[RetryStrategy.NONE],
+        description: "Input validation or schema error",
+        troubleshooting: [
+          "Check input parameters format",
+          "Verify required fields are provided",
+          "Validate data types and ranges",
+          "Review API documentation"
+        ]
+      },
+      [ErrorCategory2.TIMEOUT]: {
+        category: ErrorCategory2.TIMEOUT,
+        retryStrategy: RetryStrategy.CONSERVATIVE,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.CONSERVATIVE],
+        description: "Operation timeout error",
+        troubleshooting: [
+          "Increase timeout values",
+          "Check network latency",
+          "Verify system resources",
+          "Split operations into smaller chunks"
+        ]
+      },
+      [ErrorCategory2.RATE_LIMIT]: {
+        category: ErrorCategory2.RATE_LIMIT,
+        retryStrategy: RetryStrategy.CONSERVATIVE,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.CONSERVATIVE],
+        maxAttempts: 2,
+        // Override: limited retries to avoid further rate limiting
+        baseDelayMs: 5e3,
+        // Override: longer delays for rate limits
+        description: "Rate limit or quota exceeded",
+        troubleshooting: [
+          "Reduce request frequency",
+          "Implement request batching",
+          "Check rate limit headers",
+          "Wait for quota reset"
+        ]
+      },
+      [ErrorCategory2.CONFIGURATION]: {
+        category: ErrorCategory2.CONFIGURATION,
+        retryStrategy: RetryStrategy.NONE,
+        isRetryable: false,
+        ...RETRY_STRATEGIES[RetryStrategy.NONE],
+        description: "Configuration or setup error",
+        troubleshooting: [
+          "Check environment variables",
+          "Verify configuration files",
+          "Review setup documentation",
+          "Check required dependencies"
+        ]
+      },
+      [ErrorCategory2.UNKNOWN]: {
+        category: ErrorCategory2.UNKNOWN,
+        retryStrategy: RetryStrategy.EXPONENTIAL,
+        isRetryable: true,
+        ...RETRY_STRATEGIES[RetryStrategy.EXPONENTIAL],
+        maxAttempts: 2,
+        // Override: conservative retries for unknown errors
+        description: "Unknown or unclassified error",
+        troubleshooting: [
+          "Check logs for more details",
+          "Verify system status",
+          "Try again with debug logging",
+          "Contact support if persists"
+        ]
+      }
+    };
+    function classifyError(error) {
+      const errorMessage = error?.message || error?.toString() || "";
+      const errorLower = errorMessage.toLowerCase();
+      for (const [category, patterns] of Object.entries(LIT_ERROR_PATTERNS)) {
+        for (const pattern of patterns) {
+          if (pattern.test(errorMessage) || pattern.test(errorLower)) {
+            const classification = CLASSIFICATION_RULES[category];
+            return {
+              ...classification,
+              description: `${classification.description}: ${errorMessage.slice(0, 100)}`
+            };
+          }
+        }
+      }
+      const unknownClassification = CLASSIFICATION_RULES[ErrorCategory2.UNKNOWN];
+      return {
+        ...unknownClassification,
+        description: `${unknownClassification.description}: ${errorMessage.slice(0, 100)}`
+      };
+    }
+    function getRetryConfigFromClassification(classification) {
+      return {
+        maxAttempts: classification.maxAttempts,
+        initialDelayMs: classification.baseDelayMs,
+        maxDelayMs: classification.maxDelayMs,
+        backoffMultiplier: RETRY_STRATEGIES[classification.retryStrategy].multiplier,
+        retryableErrors: ["*"]
+        // Classification already determined retryability
+      };
+    }
+    function analyzeError(error) {
+      const classification = classifyError(error);
+      return {
+        ...classification,
+        originalError: error,
+        errorMessage: error?.message || error?.toString() || "Unknown error",
+        errorStack: error?.stack,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        retryConfig: getRetryConfigFromClassification(classification)
+      };
+    }
+    function createErrorReport(error) {
+      const analysis = analyzeError(error);
+      const report = [
+        `\u{1F50D} Error Analysis Report`,
+        `=====================================`,
+        `Category: ${analysis.category.toUpperCase()}`,
+        `Retryable: ${analysis.isRetryable ? "\u2705 Yes" : "\u274C No"}`,
+        `Strategy: ${analysis.retryStrategy}`,
+        `Max Attempts: ${analysis.maxAttempts}`,
+        `Description: ${analysis.description}`,
+        `Timestamp: ${analysis.timestamp}`,
+        ``,
+        `Original Error: ${analysis.errorMessage}`,
+        ``
+      ];
+      if (analysis.troubleshooting && analysis.troubleshooting.length > 0) {
+        report.push(`\u{1F6E0}\uFE0F  Troubleshooting Steps:`);
+        analysis.troubleshooting.forEach((step, index) => {
+          report.push(`   ${index + 1}. ${step}`);
+        });
+        report.push("");
+      }
+      return report.join("\n");
+    }
+    exports.litProtocolErrors = {
+      isNetworkError: (error) => classifyError(error).category === ErrorCategory2.NETWORK,
+      isProtocolError: (error) => classifyError(error).category === ErrorCategory2.PROTOCOL,
+      isAuthenticationError: (error) => classifyError(error).category === ErrorCategory2.AUTHENTICATION,
+      isResourceError: (error) => classifyError(error).category === ErrorCategory2.RESOURCE,
+      isTimeoutError: (error) => classifyError(error).category === ErrorCategory2.TIMEOUT,
+      isRateLimitError: (error) => classifyError(error).category === ErrorCategory2.RATE_LIMIT,
+      isConfigurationError: (error) => classifyError(error).category === ErrorCategory2.CONFIGURATION,
+      isRetryable: (error) => classifyError(error).isRetryable
+    };
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/session-signature-cache.js
+var require_session_signature_cache = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/session-signature-cache.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sessionSignatureCache = exports.DEFAULT_CACHE_CONFIG = void 0;
+    exports.generateSessionSignaturesWithCache = generateSessionSignaturesWithCache;
+    exports.configureSessionSignatureCache = configureSessionSignatureCache;
+    exports.clearSessionSignatureCache = clearSessionSignatureCache;
+    exports.getSessionSignatureCacheStats = getSessionSignatureCacheStats;
+    var debug_logger_1 = require_debug_logger();
+    exports.DEFAULT_CACHE_CONFIG = {
+      maxEntries: 50,
+      bufferTimeMs: 6e4,
+      // 1 minute buffer before expiration
+      enableLogging: true
+    };
+    var SessionSignatureCache = class {
+      constructor(config = {}) {
+        this.cache = /* @__PURE__ */ new Map();
+        this.config = { ...exports.DEFAULT_CACHE_CONFIG, ...config };
+      }
+      /**
+       * Generate cache key from PKP and context
+       */
+      generateCacheKey(pkpTokenId, litActionCid, signerAddress, network) {
+        return `${signerAddress}-${network}-${pkpTokenId}-${litActionCid}`;
+      }
+      /**
+       * Check if cache entry is still valid
+       */
+      isEntryValid(entry) {
+        const now2 = /* @__PURE__ */ new Date();
+        const expirationWithBuffer = new Date(entry.expiration.getTime() - this.config.bufferTimeMs);
+        return now2 < expirationWithBuffer;
+      }
+      /**
+       * Clean expired entries from cache
+       */
+      cleanExpiredEntries() {
+        const now2 = /* @__PURE__ */ new Date();
+        let cleanedCount = 0;
+        for (const [key2, entry] of this.cache.entries()) {
+          if (now2 >= entry.expiration) {
+            this.cache.delete(key2);
+            cleanedCount++;
+          }
+        }
+        if (cleanedCount > 0 && this.config.enableLogging) {
+          (0, debug_logger_1.debugInfo)("CACHE", `\u{1F9F9} Cleaned ${cleanedCount} expired session signature entries`);
+        }
+      }
+      /**
+       * Enforce cache size limits
+       */
+      enforceCacheSize() {
+        if (this.cache.size <= this.config.maxEntries) {
+          return;
+        }
+        const entries = Array.from(this.cache.entries()).sort(([, a], [, b]) => a.createdAt.getTime() - b.createdAt.getTime());
+        const toRemove = entries.slice(0, this.cache.size - this.config.maxEntries);
+        for (const [key2] of toRemove) {
+          this.cache.delete(key2);
+        }
+        if (this.config.enableLogging) {
+          (0, debug_logger_1.debugInfo)("CACHE", `\u{1F4E6} Removed ${toRemove.length} oldest cache entries to maintain size limit`);
+        }
+      }
+      /**
+       * Get cached session signatures if valid
+       */
+      get(pkpTokenId, litActionCid, signerAddress, network) {
+        this.cleanExpiredEntries();
+        const cacheKey = this.generateCacheKey(pkpTokenId, litActionCid, signerAddress, network);
+        const entry = this.cache.get(cacheKey);
+        if (!entry) {
+          if (this.config.enableLogging) {
+            (0, debug_logger_1.debugLog)("CACHE", `\u274C Session signatures cache miss: ${cacheKey}`);
+          }
+          return null;
+        }
+        if (!this.isEntryValid(entry)) {
+          this.cache.delete(cacheKey);
+          if (this.config.enableLogging) {
+            (0, debug_logger_1.debugWarn)("CACHE", `\u23F0 Session signatures expired: ${cacheKey}`);
+          }
+          return null;
+        }
+        if (this.config.enableLogging) {
+          const timeUntilExpiry = entry.expiration.getTime() - Date.now();
+          (0, debug_logger_1.debugInfo)("CACHE", `\u2705 Session signatures cache hit: ${cacheKey} (expires in ${Math.round(timeUntilExpiry / 1e3)}s)`);
+        }
+        return entry.sessionSigs;
+      }
+      /**
+       * Cache session signatures
+       */
+      set(pkpTokenId, litActionCid, signerAddress, network, sessionSigs, expiration) {
+        const cacheKey = this.generateCacheKey(pkpTokenId, litActionCid, signerAddress, network);
+        const entry = {
+          sessionSigs,
+          expiration,
+          pkpTokenId,
+          litActionCid,
+          signerAddress,
+          network,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        this.cache.set(cacheKey, entry);
+        if (this.config.enableLogging) {
+          const timeUntilExpiry = expiration.getTime() - Date.now();
+          (0, debug_logger_1.debugInfo)("CACHE", `\u{1F4BE} Cached session signatures: ${cacheKey} (expires in ${Math.round(timeUntilExpiry / 1e3)}s)`);
+        }
+        this.enforceCacheSize();
+      }
+      /**
+       * Clear all cached session signatures
+       */
+      clear() {
+        const size = this.cache.size;
+        this.cache.clear();
+        if (this.config.enableLogging) {
+          (0, debug_logger_1.debugInfo)("CACHE", `\u{1F5D1}\uFE0F Cleared ${size} cached session signature entries`);
+        }
+      }
+      /**
+       * Get cache statistics
+       */
+      getStats() {
+        this.cleanExpiredEntries();
+        return {
+          size: this.cache.size,
+          maxEntries: this.config.maxEntries,
+          utilizationPercent: Math.round(this.cache.size / this.config.maxEntries * 100)
+        };
+      }
+      /**
+       * Remove specific cache entry
+       */
+      delete(pkpTokenId, litActionCid, signerAddress, network) {
+        const cacheKey = this.generateCacheKey(pkpTokenId, litActionCid, signerAddress, network);
+        const deleted = this.cache.delete(cacheKey);
+        if (deleted && this.config.enableLogging) {
+          (0, debug_logger_1.debugInfo)("CACHE", `\u{1F5D1}\uFE0F Removed session signatures from cache: ${cacheKey}`);
+        }
+        return deleted;
+      }
+    };
+    exports.sessionSignatureCache = new SessionSignatureCache();
+    async function generateSessionSignaturesWithCache(litNodeClient, sessionConfig, pkpTokenId, litActionCid, signerAddress, network = "chipotle") {
+      const cached = exports.sessionSignatureCache.get(pkpTokenId, litActionCid, signerAddress, network);
+      if (cached) {
+        return cached;
+      }
+      (0, debug_logger_1.debugInfo)("CACHE", "\u{1F510} Generating new session signatures (cache miss)...");
+      const sessionSigs = await litNodeClient.getSessionSigs(sessionConfig);
+      const expiration = new Date(sessionConfig.expiration);
+      exports.sessionSignatureCache.set(pkpTokenId, litActionCid, signerAddress, network, sessionSigs, expiration);
+      const sigCount = Object.keys(sessionSigs).length;
+      (0, debug_logger_1.debugInfo)("CACHE", `\u2705 Generated and cached ${sigCount} session signatures`);
+      return sessionSigs;
+    }
+    function configureSessionSignatureCache(config) {
+      Object.assign(exports.sessionSignatureCache["config"], config);
+    }
+    function clearSessionSignatureCache() {
+      exports.sessionSignatureCache.clear();
+    }
+    function getSessionSignatureCacheStats() {
+      return exports.sessionSignatureCache.getStats();
+    }
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/connection-helpers.js
+var require_connection_helpers = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/chunks/connection-helpers.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        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 === void 0)
+        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() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2)
+            if (Object.prototype.hasOwnProperty.call(o2, k))
+              ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule)
+          return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+            if (k[i] !== "default")
+              __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NETWORK_TIMEOUTS = exports.DEFAULT_RETRY_CONFIG = void 0;
+    exports.sleep = sleep;
+    exports.isRetryableError = isRetryableError;
+    exports.calculateDelay = calculateDelay;
+    exports.withRetry = withRetry;
+    exports.connectLitNodeClient = connectLitNodeClient;
+    exports.connectLitContracts = connectLitContracts;
+    exports.validateLitNodeConnection = validateLitNodeConnection;
+    exports.generateSessionSignatures = generateSessionSignatures;
+    exports.validateLitNodeReadiness = validateLitNodeReadiness;
+    exports.executeLitAction = executeLitAction;
+    exports.executePkpOperation = executePkpOperation;
+    exports.getNetworkTimeouts = getNetworkTimeouts;
+    var debug_logger_1 = require_debug_logger();
+    var error_classification_1 = require_error_classification();
+    exports.DEFAULT_RETRY_CONFIG = {
+      maxAttempts: 5,
+      // Increased from 3 for PKP operations
+      initialDelayMs: 2e3,
+      // Increased from 1000ms for PKP operations
+      maxDelayMs: 6e4,
+      // Increased from 30000ms for PKP operations
+      backoffMultiplier: 2,
+      retryableErrors: [
+        "request_timeout",
+        "network error",
+        "connection failed",
+        "ENOTFOUND",
+        "ECONNREFUSED",
+        "ETIMEDOUT",
+        "socket hang up",
+        "timeout",
+        // PKP-specific errors
+        "signing shares",
+        "There was an error getting the signing shares",
+        "PKP validation",
+        "pkp validation failed",
+        "resource validation",
+        "ipfs propagation",
+        "session.*expired",
+        "NodeError",
+        "Response from the nodes",
+        "consensus",
+        "threshold"
+      ]
+    };
+    function sleep(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    function isRetryableError(error, retryableErrors = exports.DEFAULT_RETRY_CONFIG.retryableErrors) {
+      if (!error)
+        return false;
+      const classification = (0, error_classification_1.classifyError)(error);
+      if (classification.isRetryable !== void 0) {
+        (0, debug_logger_1.debugInfo)("ERROR_CLASSIFICATION", `Error classified as: ${classification.category} (retryable: ${classification.isRetryable})`);
+        return classification.isRetryable;
+      }
+      const errorMessage = error.message || error.toString() || "";
+      const errorLower = errorMessage.toLowerCase();
+      return retryableErrors.some((pattern) => errorLower.includes(pattern.toLowerCase()));
+    }
+    function calculateDelay(attempt, config) {
+      const exponentialDelay = Math.min(config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt - 1), config.maxDelayMs);
+      const jitter = exponentialDelay * 0.25 * (Math.random() - 0.5);
+      return Math.max(100, exponentialDelay + jitter);
+    }
+    async function withRetry(operation, config = {}, operationName = "operation") {
+      let finalConfig = { ...exports.DEFAULT_RETRY_CONFIG, ...config };
+      const tracker = new debug_logger_1.PerformanceTracker(`Retry ${operationName}`);
+      let lastError;
+      let errorClassification = null;
+      for (let attempt = 1; attempt <= finalConfig.maxAttempts; attempt++) {
+        try {
+          (0, debug_logger_1.debugInfo)("RETRY", `\u{1F504} [${operationName}] Attempt ${attempt}/${finalConfig.maxAttempts}`);
+          const startTime = Date.now();
+          const result = await operation();
+          const duration = Date.now() - startTime;
+          (0, debug_logger_1.debugInfo)("RETRY", `\u2705 [${operationName}] Success after ${duration}ms (attempt ${attempt})`);
+          debug_logger_1.networkMetrics.recordRequest(operationName, true, duration);
+          tracker.end(true);
+          return result;
+        } catch (error) {
+          lastError = error;
+          const errorMessage = error?.message || error?.toString() || "Unknown error";
+          errorClassification = (0, error_classification_1.classifyError)(error);
+          if (attempt === 1 && errorClassification) {
+            const intelligentConfig = (0, error_classification_1.getRetryConfigFromClassification)(errorClassification);
+            finalConfig = {
+              ...finalConfig,
+              ...intelligentConfig,
+              maxAttempts: Math.min(finalConfig.maxAttempts, intelligentConfig.maxAttempts)
+            };
+            (0, debug_logger_1.debugInfo)("RETRY", `\u{1F9E0} Intelligent retry strategy applied: ${errorClassification.category} (${errorClassification.retryStrategy})`);
+            (0, debug_logger_1.debugInfo)("RETRY", `\u{1F4CA} Adjusted config: max=${finalConfig.maxAttempts}, delay=${finalConfig.initialDelayMs}ms`);
+          }
+          (0, debug_logger_1.debugWarn)("RETRY", `\u26A0\uFE0F [${operationName}] Attempt ${attempt} failed:`, {
+            error: errorMessage,
+            attempt,
+            category: errorClassification.category,
+            retryable: errorClassification.isRetryable
+          });
+          debug_logger_1.networkMetrics.recordRequest(operationName, false, 0, errorMessage);
+          if (attempt >= finalConfig.maxAttempts) {
+            (0, debug_logger_1.debugError)("RETRY", `\u274C [${operationName}] All attempts failed. Last error:`, { error: errorMessage });
+            if (errorClassification) {
+              const errorReport = (0, error_classification_1.createErrorReport)(error);
+              (0, debug_logger_1.debugError)("RETRY", `\u{1F4CB} Error Analysis Report:
+${errorReport}`);
+            }
+            tracker.end(false);
+            break;
+          }
+          if (!errorClassification.isRetryable) {
+            (0, debug_logger_1.debugError)("RETRY", `\u{1F6AB} [${operationName}] Non-retryable error (${errorClassification.category}):`, { error: errorMessage });
+            if (errorClassification.troubleshooting) {
+              (0, debug_logger_1.debugInfo)("RETRY", `\u{1F4A1} Troubleshooting suggestions:
+   ${errorClassification.troubleshooting.join("\n   ")}`);
+            }
+            tracker.end(false);
+            break;
+          }
+          const delayMs = calculateDelay(attempt, finalConfig);
+          (0, debug_logger_1.debugInfo)("RETRY", `\u23F3 [${operationName}] Waiting ${delayMs}ms before retry... (${errorClassification.retryStrategy} strategy)`);
+          await sleep(delayMs);
+        }
+      }
+      throw lastError;
+    }
+    async function connectLitNodeClient(litNodeClient, config = {}) {
+      const network = litNodeClient?.config?.litNetwork || "unknown";
+      return withRetry(async () => {
+        if (!litNodeClient) {
+          throw new Error("LIT Node Client is null or undefined");
+        }
+        const startTime = Date.now();
+        (0, debug_logger_1.logConnectionAttempt)(network, 1, config.maxAttempts || exports.DEFAULT_RETRY_CONFIG.maxAttempts);
+        await litNodeClient.connect();
+        (0, debug_logger_1.debugInfo)("CONNECTION", `\u23F3 Waiting for LIT Node Client to be ready...`);
+        const readyTimeout = 3e4;
+        const readyStartTime = Date.now();
+        while (!litNodeClient.ready && Date.now() - readyStartTime < readyTimeout) {
+          await sleep(500);
+        }
+        if (!litNodeClient.ready) {
+          throw new Error(`LIT Node Client failed to become ready within ${readyTimeout}ms`);
+        }
+        const latency = Date.now() - startTime;
+        (0, debug_logger_1.debugInfo)("CONNECTION", `\u2705 LIT Node Client is ready (${litNodeClient.ready})`);
+        (0, debug_logger_1.logConnectionSuccess)(network, latency);
+      }, config, "LIT Node Client Connection");
+    }
+    async function connectLitContracts(litContracts, config = {}) {
+      return withRetry(async () => {
+        if (!litContracts) {
+          throw new Error("LIT Contracts is null or undefined");
+        }
+        console.log(`\u{1F517} Connecting to LIT Contracts: ${litContracts.network || "unknown"}`);
+        await litContracts.connect();
+        console.log("\u2705 LIT Contracts connected successfully");
+      }, config, "LIT Contracts Connection");
+    }
+    async function validateLitNodeConnection(litNodeClient) {
+      try {
+        const startTime = Date.now();
+        if (!litNodeClient) {
+          return { isValid: false, error: "LIT Node Client is null or undefined" };
+        }
+        await litNodeClient.getLatestBlockhash();
+        const latencyMs = Date.now() - startTime;
+        return { isValid: true, latencyMs };
+      } catch (error) {
+        return {
+          isValid: false,
+          error: error?.message || error?.toString() || "Unknown validation error"
+        };
+      }
+    }
+    async function generateSessionSignatures(litNodeClient, sessionConfig, config = {}, pkpTokenId, litActionCid, signerAddress, network = "chipotle") {
+      if (pkpTokenId && litActionCid && signerAddress) {
+        const { sessionSignatureCache } = await Promise.resolve().then(() => __importStar(require_session_signature_cache()));
+        const cached = sessionSignatureCache.get(pkpTokenId, litActionCid, signerAddress, network);
+        if (cached) {
+          const sigCount = Object.keys(cached).length;
+          (0, debug_logger_1.debugInfo)("SESSION", `\u{1F504} Using cached session signatures (${sigCount} sigs)`);
+          return cached;
+        }
+      }
+      return withRetry(async () => {
+        (0, debug_logger_1.debugInfo)("SESSION", "\u{1F510} Generating new session signatures...");
+        const sessionSigs = await litNodeClient.getSessionSigs(sessionConfig);
+        const sigCount = Object.keys(sessionSigs).length;
+        if (pkpTokenId && litActionCid && signerAddress) {
+          const { sessionSignatureCache } = await Promise.resolve().then(() => __importStar(require_session_signature_cache()));
+          const expiration = new Date(sessionConfig.expiration);
+          sessionSignatureCache.set(pkpTokenId, litActionCid, signerAddress, network, sessionSigs, expiration);
+        }
+        (0, debug_logger_1.debugInfo)("SESSION", `\u2705 Generated ${sigCount} session signatures`);
+        return sessionSigs;
+      }, config, "Session Signature Generation");
+    }
+    async function validateLitNodeReadiness(litNodeClient) {
+      if (!litNodeClient) {
+        throw new Error("LIT Node Client is null or undefined");
+      }
+      if (!litNodeClient.ready) {
+        (0, debug_logger_1.debugWarn)("CONNECTION", "\u26A0\uFE0F LIT Node Client not ready, attempting to reconnect...");
+        await litNodeClient.connect();
+        const readyTimeout = 15e3;
+        const startTime = Date.now();
+        while (!litNodeClient.ready && Date.now() - startTime < readyTimeout) {
+          await sleep(500);
+        }
+        if (!litNodeClient.ready) {
+          throw new Error("LIT Node Client is not ready for operations");
+        }
+      }
+      (0, debug_logger_1.debugInfo)("CONNECTION", "\u2705 LIT Node Client readiness validated");
+    }
+    async function executeLitAction(litNodeClient, executionConfig, config = {}) {
+      const cid = executionConfig.ipfsId;
+      return withRetry(async () => {
+        const startTime = Date.now();
+        await validateLitNodeReadiness(litNodeClient);
+        (0, debug_logger_1.logLitActionExecution)(cid, executionConfig.jsParams);
+        (0, debug_logger_1.logRequest)("LIT_ACTION", "executeJs", executionConfig);
+        const result = await litNodeClient.executeJs(executionConfig);
+        const duration = Date.now() - startTime;
+        if (!result.response) {
+          (0, debug_logger_1.logError)("LIT_ACTION", "executeJs", new Error("No response from LIT Action"), duration);
+          throw new Error("No response from LIT Action");
+        }
+        (0, debug_logger_1.logResponse)("LIT_ACTION", "executeJs", result, duration);
+        (0, debug_logger_1.logLitActionResult)(cid, true, duration, result);
+        return result;
+      }, config, "LIT Action Execution");
+    }
+    async function executePkpOperation(operation, operationName, config = {}) {
+      const pkpConfig = {
+        ...exports.DEFAULT_RETRY_CONFIG,
+        ...config,
+        retryableErrors: [
+          ...exports.DEFAULT_RETRY_CONFIG.retryableErrors,
+          "pkp validation",
+          "signing shares",
+          "resource validation",
+          "ipfs propagation"
+        ]
+      };
+      return withRetry(operation, pkpConfig, `PKP ${operationName}`);
+    }
+    exports.NETWORK_TIMEOUTS = {
+      chipotle: {
+        connection: 6e4,
+        operation: 12e4,
+        pkpValidation: 18e4
+      }
+    };
+    function getNetworkTimeouts(network) {
+      return exports.NETWORK_TIMEOUTS[network] || exports.NETWORK_TIMEOUTS["chipotle"];
+    }
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/index.js
+var require_utils4 = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/utils/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        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 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_lit_action_helpers(), exports);
+    __exportStar(require_pkp_setup(), exports);
+    __exportStar(require_cid_utils(), exports);
+    __exportStar(require_connection_helpers(), exports);
+    __exportStar(require_debug_logger(), exports);
+    __exportStar(require_error_classification(), exports);
+    __exportStar(require_session_signature_cache(), exports);
+  }
+});
+
+// node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/index.js
+var require_pkg_src = __commonJS({
+  "node_modules/@gvnrdao/dh-lit-actions/pkg-dist/pkg-src/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        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 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CHIPOTLE_DEPLOYMENTS = exports.DH_LIT_ACTIONS_CHIPOTLE = void 0;
+    __exportStar(require_interfaces(), exports);
+    __exportStar(require_lit_actions_registry(), exports);
+    __exportStar(require_utils4(), exports);
+    var lit_actions_registry_1 = require_lit_actions_registry();
+    Object.defineProperty(exports, "DH_LIT_ACTIONS_CHIPOTLE", { enumerable: true, get: function() {
+      return lit_actions_registry_1.DH_LIT_ACTIONS_CHIPOTLE;
+    } });
+    Object.defineProperty(exports, "CHIPOTLE_DEPLOYMENTS", { enumerable: true, get: function() {
+      return lit_actions_registry_1.CHIPOTLE_DEPLOYMENTS;
+    } });
+  }
+});
+
 // src/constants/chunks/deployment-addresses.ts
 var deployment_addresses_exports = {};
 __export(deployment_addresses_exports, {
@@ -13352,10 +15017,10 @@ __export(ethers_exports, {
   constants: () => lib_exports2,
   errors: () => ErrorCode,
   getDefaultProvider: () => getDefaultProvider,
-  logger: () => logger48,
+  logger: () => logger47,
   providers: () => lib_exports4,
   utils: () => utils_exports,
-  version: () => version27,
+  version: () => version26,
   wordlists: () => wordlists
 });
 
@@ -13428,10 +15093,10 @@ var ErrorCode;
 })(ErrorCode || (ErrorCode = {}));
 var HEX = "0123456789abcdef";
 var Logger = class _Logger {
-  constructor(version28) {
+  constructor(version27) {
     Object.defineProperty(this, "version", {
       enumerable: true,
-      value: version28,
+      value: version27,
       writable: false
     });
   }
@@ -13646,8 +15311,8 @@ var Logger = class _Logger {
     }
     _logLevel = level;
   }
-  static from(version28) {
-    return new _Logger(version28);
+  static from(version27) {
+    return new _Logger(version27);
   }
 };
 Logger.errors = ErrorCode;
@@ -18311,10 +19976,10 @@ var Interface = class {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/abstract-provider/lib.esm/_version.js
+// node_modules/@ethersproject/abstract-provider/lib.esm/_version.js
 var version10 = "abstract-provider/5.8.0";
 
-// node_modules/ethers/node_modules/@ethersproject/abstract-provider/lib.esm/index.js
+// node_modules/@ethersproject/abstract-provider/lib.esm/index.js
 var __awaiter3 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -21037,10 +22702,10 @@ function parse(rawTransaction) {
   });
 }
 
-// node_modules/ethers/node_modules/@ethersproject/contracts/lib.esm/_version.js
+// node_modules/@ethersproject/contracts/lib.esm/_version.js
 var version14 = "contracts/5.8.0";
 
-// node_modules/ethers/node_modules/@ethersproject/contracts/lib.esm/index.js
+// node_modules/@ethersproject/contracts/lib.esm/index.js
 var __awaiter5 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -21975,73 +23640,6 @@ var ContractFactory = class {
   }
 };
 
-// node_modules/@ethersproject/wallet/node_modules/@ethersproject/abstract-provider/lib.esm/_version.js
-var version15 = "abstract-provider/5.8.0";
-
-// node_modules/@ethersproject/wallet/node_modules/@ethersproject/abstract-provider/lib.esm/index.js
-var __awaiter6 = function(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var logger20 = new Logger(version15);
-var Provider2 = class _Provider {
-  constructor() {
-    logger20.checkAbstract(new.target, _Provider);
-    defineReadOnly(this, "_isProvider", true);
-  }
-  getFeeData() {
-    return __awaiter6(this, void 0, void 0, function* () {
-      const { block, gasPrice } = yield resolveProperties({
-        block: this.getBlock("latest"),
-        gasPrice: this.getGasPrice().catch((error) => {
-          return null;
-        })
-      });
-      let lastBaseFeePerGas = null, maxFeePerGas = null, maxPriorityFeePerGas = null;
-      if (block && block.baseFeePerGas) {
-        lastBaseFeePerGas = block.baseFeePerGas;
-        maxPriorityFeePerGas = BigNumber.from("1500000000");
-        maxFeePerGas = block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas);
-      }
-      return { lastBaseFeePerGas, maxFeePerGas, maxPriorityFeePerGas, gasPrice };
-    });
-  }
-  // Alias for "on"
-  addListener(eventName, listener) {
-    return this.on(eventName, listener);
-  }
-  // Alias for "off"
-  removeListener(eventName, listener) {
-    return this.off(eventName, listener);
-  }
-  static isProvider(value) {
-    return !!(value && value._isProvider);
-  }
-};
-
 // node_modules/@ethersproject/basex/lib.esm/index.js
 var BaseX = class {
   constructor(alphabet) {
@@ -22125,10 +23723,10 @@ var SupportedAlgorithm;
 })(SupportedAlgorithm || (SupportedAlgorithm = {}));
 
 // node_modules/@ethersproject/sha2/lib.esm/_version.js
-var version16 = "sha2/5.8.0";
+var version15 = "sha2/5.8.0";
 
 // node_modules/@ethersproject/sha2/lib.esm/sha2.js
-var logger21 = new Logger(version16);
+var logger20 = new Logger(version15);
 function ripemd160(data) {
   return "0x" + import_hash3.default.ripemd160().update(arrayify(data)).digest("hex");
 }
@@ -22140,7 +23738,7 @@ function sha512(data) {
 }
 function computeHmac(algorithm, key2, data) {
   if (!SupportedAlgorithm[algorithm]) {
-    logger21.throwError("unsupported algorithm " + algorithm, Logger.errors.UNSUPPORTED_OPERATION, {
+    logger20.throwError("unsupported algorithm " + algorithm, Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "hmac",
       algorithm
     });
@@ -22185,14 +23783,14 @@ function pbkdf2(password, salt, iterations, keylen, hashAlgorithm) {
 }
 
 // node_modules/@ethersproject/wordlists/lib.esm/_version.js
-var version17 = "wordlists/5.8.0";
+var version16 = "wordlists/5.8.0";
 
 // node_modules/@ethersproject/wordlists/lib.esm/wordlist.js
 var exportWordlist = false;
-var logger22 = new Logger(version17);
+var logger21 = new Logger(version16);
 var Wordlist = class _Wordlist {
   constructor(locale) {
-    logger22.checkAbstract(new.target, _Wordlist);
+    logger21.checkAbstract(new.target, _Wordlist);
     defineReadOnly(this, "locale", locale);
   }
   // Subclasses may override this
@@ -22267,10 +23865,10 @@ var wordlists = {
 };
 
 // node_modules/@ethersproject/hdnode/lib.esm/_version.js
-var version18 = "hdnode/5.8.0";
+var version17 = "hdnode/5.8.0";
 
 // node_modules/@ethersproject/hdnode/lib.esm/index.js
-var logger23 = new Logger(version18);
+var logger22 = new Logger(version17);
 var N = BigNumber.from("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
 var MasterSecret = toUtf8Bytes("Bitcoin seed");
 var HardenedBit = 2147483648;
@@ -22293,7 +23891,7 @@ function getWordlist(wordlist2) {
   if (typeof wordlist2 === "string") {
     const words2 = wordlists[wordlist2];
     if (words2 == null) {
-      logger23.throwArgumentError("unknown locale", "wordlist", wordlist2);
+      logger22.throwArgumentError("unknown locale", "wordlist", wordlist2);
     }
     return words2;
   }
@@ -22451,7 +24049,7 @@ var HDNode = class _HDNode {
   static fromExtendedKey(extendedKey) {
     const bytes = Base58.decode(extendedKey);
     if (bytes.length !== 82 || base58check(bytes.slice(0, 78)) !== extendedKey) {
-      logger23.throwArgumentError("invalid extended key", "extendedKey", "[REDACTED]");
+      logger22.throwArgumentError("invalid extended key", "extendedKey", "[REDACTED]");
     }
     const depth = bytes[4];
     const parentFingerprint = hexlify(bytes.slice(5, 9));
@@ -22469,7 +24067,7 @@ var HDNode = class _HDNode {
         }
         return new _HDNode(_constructorGuard4, hexlify(key2.slice(1)), null, parentFingerprint, chainCode, index, depth, null);
     }
-    return logger23.throwArgumentError("invalid extended key", "extendedKey", "[REDACTED]");
+    return logger22.throwArgumentError("invalid extended key", "extendedKey", "[REDACTED]");
   }
 };
 function mnemonicToSeed(mnemonic, password) {
@@ -22481,7 +24079,7 @@ function mnemonicToSeed(mnemonic, password) {
 }
 function mnemonicToEntropy(mnemonic, wordlist2) {
   wordlist2 = getWordlist(wordlist2);
-  logger23.checkNormalize();
+  logger22.checkNormalize();
   const words2 = wordlist2.split(mnemonic);
   if (words2.length % 3 !== 0) {
     throw new Error("invalid mnemonic");
@@ -22545,16 +24143,16 @@ function isValidMnemonic(mnemonic, wordlist2) {
 }
 function getAccountPath(index) {
   if (typeof index !== "number" || index < 0 || index >= HardenedBit || index % 1) {
-    logger23.throwArgumentError("invalid account index", "index", index);
+    logger22.throwArgumentError("invalid account index", "index", index);
   }
   return `m/44'/60'/${index}'/0/0`;
 }
 
 // node_modules/@ethersproject/random/lib.esm/_version.js
-var version19 = "random/5.8.0";
+var version18 = "random/5.8.0";
 
 // node_modules/@ethersproject/random/lib.esm/random.js
-var logger24 = new Logger(version19);
+var logger23 = new Logger(version18);
 function getGlobal() {
   if (typeof self !== "undefined") {
     return self;
@@ -22570,10 +24168,10 @@ function getGlobal() {
 var anyGlobal = getGlobal();
 var crypto = anyGlobal.crypto || anyGlobal.msCrypto;
 if (!crypto || !crypto.getRandomValues) {
-  logger24.warn("WARNING: Missing strong random number source");
+  logger23.warn("WARNING: Missing strong random number source");
   crypto = {
     getRandomValues: function(buffer) {
-      return logger24.throwError("no secure random source avaialble", Logger.errors.UNSUPPORTED_OPERATION, {
+      return logger23.throwError("no secure random source avaialble", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "crypto.getRandomValues"
       });
     }
@@ -22581,7 +24179,7 @@ if (!crypto || !crypto.getRandomValues) {
 }
 function randomBytes(length) {
   if (length <= 0 || length > 1024 || length % 1 || length != length) {
-    logger24.throwArgumentError("invalid length", "length", length);
+    logger23.throwArgumentError("invalid length", "length", length);
   }
   const result = new Uint8Array(length);
   crypto.getRandomValues(result);
@@ -22604,7 +24202,7 @@ function shuffled(array) {
 var import_aes_js = __toESM(require_aes_js());
 
 // node_modules/@ethersproject/json-wallets/lib.esm/_version.js
-var version20 = "json-wallets/5.8.0";
+var version19 = "json-wallets/5.8.0";
 
 // node_modules/@ethersproject/json-wallets/lib.esm/utils.js
 function looseArrayify(hexString) {
@@ -22659,7 +24257,7 @@ function uuidV4(randomBytes2) {
 }
 
 // node_modules/@ethersproject/json-wallets/lib.esm/crowdsale.js
-var logger25 = new Logger(version20);
+var logger24 = new Logger(version19);
 var CrowdsaleAccount = class extends Description {
   isCrowdsaleAccount(value) {
     return !!(value && value._isCrowdsaleAccount);
@@ -22671,7 +24269,7 @@ function decrypt(json, password) {
   const ethaddr = getAddress(searchPath(data, "ethaddr"));
   const encseed = looseArrayify(searchPath(data, "encseed"));
   if (!encseed || encseed.length % 16 !== 0) {
-    logger25.throwArgumentError("invalid encseed", "json", json);
+    logger24.throwArgumentError("invalid encseed", "json", json);
   }
   const key2 = arrayify(pbkdf2(password, password, 2e3, 32, "sha256")).slice(0, 16);
   const iv = encseed.slice(0, 16);
@@ -22734,7 +24332,7 @@ function getJsonWalletAddress(json) {
 // node_modules/@ethersproject/json-wallets/lib.esm/keystore.js
 var import_aes_js2 = __toESM(require_aes_js());
 var import_scrypt_js = __toESM(require_scrypt());
-var __awaiter7 = function(thisArg, _arguments, P, generator) {
+var __awaiter6 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -22761,7 +24359,7 @@ var __awaiter7 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger26 = new Logger(version20);
+var logger25 = new Logger(version19);
 function hasMnemonic(value) {
   return value != null && value.mnemonic && value.mnemonic.phrase;
 }
@@ -22788,7 +24386,7 @@ function _getAccount(data, key2) {
   }
   const privateKey = _decrypt(data, key2.slice(0, 16), ciphertext);
   if (!privateKey) {
-    logger26.throwError("unsupported cipher", Logger.errors.UNSUPPORTED_OPERATION, {
+    logger25.throwError("unsupported cipher", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "decrypt"
     });
   }
@@ -22842,7 +24440,7 @@ function _computeKdfKey(data, password, pbkdf2Func, scryptFunc, progressCallback
   const kdf = searchPath(data, "crypto/kdf");
   if (kdf && typeof kdf === "string") {
     const throwError = function(name, value) {
-      return logger26.throwArgumentError("invalid key-derivation function parameters", name, value);
+      return logger25.throwArgumentError("invalid key-derivation function parameters", name, value);
     };
     if (kdf.toLowerCase() === "scrypt") {
       const salt = looseArrayify(searchPath(data, "crypto/kdfparams/salt"));
@@ -22879,7 +24477,7 @@ function _computeKdfKey(data, password, pbkdf2Func, scryptFunc, progressCallback
       return pbkdf2Func(passwordBytes, salt, count, dkLen, prfFunc);
     }
   }
-  return logger26.throwArgumentError("unsupported key-derivation function", "kdf", kdf);
+  return logger25.throwArgumentError("unsupported key-derivation function", "kdf", kdf);
 }
 function decryptSync(json, password) {
   const data = JSON.parse(json);
@@ -22887,7 +24485,7 @@ function decryptSync(json, password) {
   return _getAccount(data, key2);
 }
 function decrypt2(json, password, progressCallback) {
-  return __awaiter7(this, void 0, void 0, function* () {
+  return __awaiter6(this, void 0, void 0, function* () {
     const data = JSON.parse(json);
     const key2 = yield _computeKdfKey(data, password, pbkdf22, import_scrypt_js.default.scrypt, progressCallback);
     return _getAccount(data, key2);
@@ -23046,10 +24644,10 @@ function decryptJsonWalletSync(json, password) {
 }
 
 // node_modules/@ethersproject/wallet/lib.esm/_version.js
-var version21 = "wallet/5.8.0";
+var version20 = "wallet/5.8.0";
 
 // node_modules/@ethersproject/wallet/lib.esm/index.js
-var __awaiter8 = function(thisArg, _arguments, P, generator) {
+var __awaiter7 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -23076,7 +24674,7 @@ var __awaiter8 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger27 = new Logger(version21);
+var logger26 = new Logger(version20);
 function isAccount(value) {
   return value != null && isHexString(value.privateKey, 32) && value.address != null;
 }
@@ -23092,7 +24690,7 @@ var Wallet = class _Wallet extends Signer {
       defineReadOnly(this, "_signingKey", () => signingKey);
       defineReadOnly(this, "address", computeAddress(this.publicKey));
       if (this.address !== getAddress(privateKey.address)) {
-        logger27.throwArgumentError("privateKey/address mismatch", "privateKey", "[REDACTED]");
+        logger26.throwArgumentError("privateKey/address mismatch", "privateKey", "[REDACTED]");
       }
       if (hasMnemonic2(privateKey)) {
         const srcMnemonic = privateKey.mnemonic;
@@ -23104,7 +24702,7 @@ var Wallet = class _Wallet extends Signer {
         const mnemonic = this.mnemonic;
         const node = HDNode.fromMnemonic(mnemonic.phrase, null, mnemonic.locale).derivePath(mnemonic.path);
         if (computeAddress(node.privateKey) !== this.address) {
-          logger27.throwArgumentError("mnemonic/address mismatch", "privateKey", "[REDACTED]");
+          logger26.throwArgumentError("mnemonic/address mismatch", "privateKey", "[REDACTED]");
         }
       } else {
         defineReadOnly(this, "_mnemonic", () => null);
@@ -23112,7 +24710,7 @@ var Wallet = class _Wallet extends Signer {
     } else {
       if (SigningKey.isSigningKey(privateKey)) {
         if (privateKey.curve !== "secp256k1") {
-          logger27.throwArgumentError("unsupported curve; must be secp256k1", "privateKey", "[REDACTED]");
+          logger26.throwArgumentError("unsupported curve; must be secp256k1", "privateKey", "[REDACTED]");
         }
         defineReadOnly(this, "_signingKey", () => privateKey);
       } else {
@@ -23127,8 +24725,8 @@ var Wallet = class _Wallet extends Signer {
       defineReadOnly(this, "_mnemonic", () => null);
       defineReadOnly(this, "address", computeAddress(this.publicKey));
     }
-    if (provider && !Provider2.isProvider(provider)) {
-      logger27.throwArgumentError("invalid provider", "provider", provider);
+    if (provider && !Provider.isProvider(provider)) {
+      logger26.throwArgumentError("invalid provider", "provider", provider);
     }
     defineReadOnly(this, "provider", provider || null);
   }
@@ -23151,7 +24749,7 @@ var Wallet = class _Wallet extends Signer {
     return resolveProperties(transaction).then((tx) => {
       if (tx.from != null) {
         if (getAddress(tx.from) !== this.address) {
-          logger27.throwArgumentError("transaction from address mismatch", "transaction.from", transaction.from);
+          logger26.throwArgumentError("transaction from address mismatch", "transaction.from", transaction.from);
         }
         delete tx.from;
       }
@@ -23160,15 +24758,15 @@ var Wallet = class _Wallet extends Signer {
     });
   }
   signMessage(message) {
-    return __awaiter8(this, void 0, void 0, function* () {
+    return __awaiter7(this, void 0, void 0, function* () {
       return joinSignature(this._signingKey().signDigest(hashMessage(message)));
     });
   }
   _signTypedData(domain, types, value) {
-    return __awaiter8(this, void 0, void 0, function* () {
+    return __awaiter7(this, void 0, void 0, function* () {
       const populated = yield TypedDataEncoder.resolveNames(domain, types, value, (name) => {
         if (this.provider == null) {
-          logger27.throwError("cannot resolve ENS names without a provider", Logger.errors.UNSUPPORTED_OPERATION, {
+          logger26.throwError("cannot resolve ENS names without a provider", Logger.errors.UNSUPPORTED_OPERATION, {
             operation: "resolveName",
             value: name
           });
@@ -23227,7 +24825,7 @@ function verifyTypedData(domain, types, value, signature2) {
   return recoverAddress(TypedDataEncoder.hash(domain, types, value), signature2);
 }
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/index.js
+// node_modules/@ethersproject/providers/lib.esm/index.js
 var lib_exports4 = {};
 __export(lib_exports4, {
   AlchemyProvider: () => AlchemyProvider,
@@ -23261,10 +24859,10 @@ __export(lib_exports4, {
 });
 
 // node_modules/@ethersproject/networks/lib.esm/_version.js
-var version22 = "networks/5.8.0";
+var version21 = "networks/5.8.0";
 
 // node_modules/@ethersproject/networks/lib.esm/index.js
-var logger28 = new Logger(version22);
+var logger27 = new Logger(version21);
 function isRenetworkable(value) {
   return value && typeof value.renetwork === "function";
 }
@@ -23484,12 +25082,12 @@ function getNetwork(network) {
   const standard = networks[network.name];
   if (!standard) {
     if (typeof network.chainId !== "number") {
-      logger28.throwArgumentError("invalid network chainId", "network", network);
+      logger27.throwArgumentError("invalid network chainId", "network", network);
     }
     return network;
   }
   if (network.chainId !== 0 && network.chainId !== standard.chainId) {
-    logger28.throwArgumentError("network chainId mismatch", "network", network);
+    logger27.throwArgumentError("network chainId mismatch", "network", network);
   }
   let defaultProvider = network._defaultProvider || null;
   if (defaultProvider == null && standard._defaultProvider) {
@@ -23508,10 +25106,10 @@ function getNetwork(network) {
 }
 
 // node_modules/@ethersproject/web/lib.esm/_version.js
-var version23 = "web/5.8.0";
+var version22 = "web/5.8.0";
 
 // node_modules/@ethersproject/web/lib.esm/geturl.js
-var __awaiter9 = function(thisArg, _arguments, P, generator) {
+var __awaiter8 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -23539,7 +25137,7 @@ var __awaiter9 = function(thisArg, _arguments, P, generator) {
   });
 };
 function getUrl(href, options) {
-  return __awaiter9(this, void 0, void 0, function* () {
+  return __awaiter8(this, void 0, void 0, function* () {
     if (options == null) {
       options = {};
     }
@@ -23596,7 +25194,7 @@ function getUrl(href, options) {
 }
 
 // node_modules/@ethersproject/web/lib.esm/index.js
-var __awaiter10 = function(thisArg, _arguments, P, generator) {
+var __awaiter9 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -23623,7 +25221,7 @@ var __awaiter10 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger29 = new Logger(version23);
+var logger28 = new Logger(version22);
 function staller(duration) {
   return new Promise((resolve) => {
     setTimeout(resolve, duration);
@@ -23655,10 +25253,10 @@ function unpercent(value) {
 }
 function _fetchData(connection, body, processFunc) {
   const attemptLimit = typeof connection === "object" && connection.throttleLimit != null ? connection.throttleLimit : 12;
-  logger29.assertArgument(attemptLimit > 0 && attemptLimit % 1 === 0, "invalid connection throttle limit", "connection.throttleLimit", attemptLimit);
+  logger28.assertArgument(attemptLimit > 0 && attemptLimit % 1 === 0, "invalid connection throttle limit", "connection.throttleLimit", attemptLimit);
   const throttleCallback = typeof connection === "object" ? connection.throttleCallback : null;
   const throttleSlotInterval = typeof connection === "object" && typeof connection.throttleSlotInterval === "number" ? connection.throttleSlotInterval : 100;
-  logger29.assertArgument(throttleSlotInterval > 0 && throttleSlotInterval % 1 === 0, "invalid connection throttle slot interval", "connection.throttleSlotInterval", throttleSlotInterval);
+  logger28.assertArgument(throttleSlotInterval > 0 && throttleSlotInterval % 1 === 0, "invalid connection throttle slot interval", "connection.throttleSlotInterval", throttleSlotInterval);
   const errorPassThrough = typeof connection === "object" ? !!connection.errorPassThrough : false;
   const headers = {};
   let url = null;
@@ -23671,7 +25269,7 @@ function _fetchData(connection, body, processFunc) {
     url = connection;
   } else if (typeof connection === "object") {
     if (connection == null || connection.url == null) {
-      logger29.throwArgumentError("missing URL", "connection.url", connection);
+      logger28.throwArgumentError("missing URL", "connection.url", connection);
     }
     url = connection.url;
     if (typeof connection.timeout === "number" && connection.timeout > 0) {
@@ -23688,7 +25286,7 @@ function _fetchData(connection, body, processFunc) {
     options.allowGzip = !!connection.allowGzip;
     if (connection.user != null && connection.password != null) {
       if (url.substring(0, 6) !== "https:" && connection.allowInsecureAuthentication !== true) {
-        logger29.throwError("basic authentication requires a secure https url", Logger.errors.INVALID_ARGUMENT, { argument: "url", url, user: connection.user, password: "[REDACTED]" });
+        logger28.throwError("basic authentication requires a secure https url", Logger.errors.INVALID_ARGUMENT, { argument: "url", url, user: connection.user, password: "[REDACTED]" });
       }
       const authorization = connection.user + ":" + connection.password;
       headers["authorization"] = {
@@ -23719,7 +25317,7 @@ function _fetchData(connection, body, processFunc) {
       }
       return Promise.resolve(result);
     } catch (error) {
-      logger29.throwError("processing response error", Logger.errors.SERVER_ERROR, {
+      logger28.throwError("processing response error", Logger.errors.SERVER_ERROR, {
         body: bodyify(dataMatch[1], dataMatch[2]),
         error,
         requestBody: null,
@@ -23753,7 +25351,7 @@ function _fetchData(connection, body, processFunc) {
             return;
           }
           timer2 = null;
-          reject(logger29.makeError("timeout", Logger.errors.TIMEOUT, {
+          reject(logger28.makeError("timeout", Logger.errors.TIMEOUT, {
             requestBody: bodyify(options.body, flatHeaders["content-type"]),
             requestMethod: options.method,
             timeout,
@@ -23772,7 +25370,7 @@ function _fetchData(connection, body, processFunc) {
     return { promise, cancel };
   }();
   const runningFetch = function() {
-    return __awaiter10(this, void 0, void 0, function* () {
+    return __awaiter9(this, void 0, void 0, function* () {
       for (let attempt = 0; attempt < attemptLimit; attempt++) {
         let response = null;
         try {
@@ -23806,7 +25404,7 @@ function _fetchData(connection, body, processFunc) {
           response = error.response;
           if (response == null) {
             runningTimeout.cancel();
-            logger29.throwError("missing response", Logger.errors.SERVER_ERROR, {
+            logger28.throwError("missing response", Logger.errors.SERVER_ERROR, {
               requestBody: bodyify(options.body, flatHeaders["content-type"]),
               requestMethod: options.method,
               serverError: error,
@@ -23819,7 +25417,7 @@ function _fetchData(connection, body, processFunc) {
           body2 = null;
         } else if (!errorPassThrough && (response.statusCode < 200 || response.statusCode >= 300)) {
           runningTimeout.cancel();
-          logger29.throwError("bad response", Logger.errors.SERVER_ERROR, {
+          logger28.throwError("bad response", Logger.errors.SERVER_ERROR, {
             status: response.statusCode,
             headers: response.headers,
             body: bodyify(body2, response.headers ? response.headers["content-type"] : null),
@@ -23846,7 +25444,7 @@ function _fetchData(connection, body, processFunc) {
               }
             }
             runningTimeout.cancel();
-            logger29.throwError("processing response error", Logger.errors.SERVER_ERROR, {
+            logger28.throwError("processing response error", Logger.errors.SERVER_ERROR, {
               body: bodyify(body2, response.headers ? response.headers["content-type"] : null),
               error,
               requestBody: bodyify(options.body, flatHeaders["content-type"]),
@@ -23858,7 +25456,7 @@ function _fetchData(connection, body, processFunc) {
         runningTimeout.cancel();
         return body2;
       }
-      return logger29.throwError("failed response", Logger.errors.SERVER_ERROR, {
+      return logger28.throwError("failed response", Logger.errors.SERVER_ERROR, {
         requestBody: bodyify(options.body, flatHeaders["content-type"]),
         requestMethod: options.method,
         url
@@ -23874,7 +25472,7 @@ function fetchJson(connection, json, processFunc) {
       try {
         result = JSON.parse(toUtf8String(value));
       } catch (error) {
-        logger29.throwError("invalid JSON", Logger.errors.SERVER_ERROR, {
+        logger28.throwError("invalid JSON", Logger.errors.SERVER_ERROR, {
           body: value,
           error
         });
@@ -23976,14 +25574,14 @@ function poll(func, options) {
   });
 }
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/base-provider.js
+// node_modules/@ethersproject/providers/lib.esm/base-provider.js
 import bech32 from "bech32";
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/_version.js
-var version24 = "providers/5.8.0";
+// node_modules/@ethersproject/providers/lib.esm/_version.js
+var version23 = "providers/5.8.0";
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/formatter.js
-var logger30 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/formatter.js
+var logger29 = new Logger(version23);
 var Formatter = class _Formatter {
   constructor() {
     this.formats = this.getDefaultFormats();
@@ -24150,7 +25748,7 @@ var Formatter = class _Formatter {
         return value.toLowerCase();
       }
     }
-    return logger30.throwArgumentError("invalid hash", "value", value);
+    return logger29.throwArgumentError("invalid hash", "value", value);
   }
   data(value, strict) {
     const result = this.hex(value, strict);
@@ -24200,7 +25798,7 @@ var Formatter = class _Formatter {
   hash(value, strict) {
     const result = this.hex(value, strict);
     if (hexDataLength(result) !== 32) {
-      return logger30.throwArgumentError("invalid hash", "value", value);
+      return logger29.throwArgumentError("invalid hash", "value", value);
     }
     return result;
   }
@@ -24302,15 +25900,15 @@ var Formatter = class _Formatter {
         const value2 = BigNumber.from(result.root).toNumber();
         if (value2 === 0 || value2 === 1) {
           if (result.status != null && result.status !== value2) {
-            logger30.throwArgumentError("alt-root-status/status mismatch", "value", { root: result.root, status: result.status });
+            logger29.throwArgumentError("alt-root-status/status mismatch", "value", { root: result.root, status: result.status });
           }
           result.status = value2;
           delete result.root;
         } else {
-          logger30.throwArgumentError("invalid alt-root-status", "value.root", result.root);
+          logger29.throwArgumentError("invalid alt-root-status", "value.root", result.root);
         }
       } else if (result.root.length !== 66) {
-        logger30.throwArgumentError("invalid root hash", "value.root", result.root);
+        logger29.throwArgumentError("invalid root hash", "value.root", result.root);
       }
     }
     if (result.status != null) {
@@ -24406,8 +26004,8 @@ function showThrottleMessage() {
   console.log("==========================");
 }
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/base-provider.js
-var __awaiter11 = function(thisArg, _arguments, P, generator) {
+// node_modules/@ethersproject/providers/lib.esm/base-provider.js
+var __awaiter10 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -24434,14 +26032,14 @@ var __awaiter11 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger31 = new Logger(version24);
+var logger30 = new Logger(version23);
 var MAX_CCIP_REDIRECTS = 10;
 function checkTopic(topic) {
   if (topic == null) {
     return "null";
   }
   if (hexDataLength(topic) !== 32) {
-    logger31.throwArgumentError("invalid topic", "topic", topic);
+    logger30.throwArgumentError("invalid topic", "topic", topic);
   }
   return topic.toLowerCase();
 }
@@ -24490,7 +26088,7 @@ function getEventTag2(eventName) {
   } else if (Array.isArray(eventName)) {
     return "filter:*:" + serializeTopics(eventName);
   } else if (ForkEvent.isForkEvent(eventName)) {
-    logger31.warn("not implemented");
+    logger30.warn("not implemented");
     throw new Error("not implemented");
   } else if (eventName && typeof eventName === "object") {
     return "filter:" + (eventName.address || "*") + ":" + serializeTopics(eventName.topics || []);
@@ -24595,7 +26193,7 @@ function getIpfsLink(link) {
   } else if (link.match(/^ipfs:\/\//i)) {
     link = link.substring(7);
   } else {
-    logger31.throwArgumentError("unsupported IPFS format", "link", link);
+    logger30.throwArgumentError("unsupported IPFS format", "link", link);
   }
   return `https://gateway.ipfs.io/ipfs/${link}`;
 }
@@ -24658,7 +26256,7 @@ var Resolver = class {
     return this._supportsEip2544;
   }
   _fetch(selector, parameters) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       const tx = {
         to: this.address,
         ccipReadEnabled: true,
@@ -24672,7 +26270,7 @@ var Resolver = class {
       try {
         let result = yield this.provider.call(tx);
         if (arrayify(result).length % 32 === 4) {
-          logger31.throwError("resolver threw error", Logger.errors.CALL_EXCEPTION, {
+          logger30.throwError("resolver threw error", Logger.errors.CALL_EXCEPTION, {
             transaction: tx,
             data: result
           });
@@ -24690,7 +26288,7 @@ var Resolver = class {
     });
   }
   _fetchBytes(selector, parameters) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       const result = yield this._fetch(selector, parameters);
       if (result != null) {
         return _parseBytes(result, 0);
@@ -24701,7 +26299,7 @@ var Resolver = class {
   _getAddress(coinType, hexBytes) {
     const coinInfo = coinInfos[String(coinType)];
     if (coinInfo == null) {
-      logger31.throwError(`unsupported coin type: ${coinType}`, Logger.errors.UNSUPPORTED_OPERATION, {
+      logger30.throwError(`unsupported coin type: ${coinType}`, Logger.errors.UNSUPPORTED_OPERATION, {
         operation: `getAddress(${coinType})`
       });
     }
@@ -24729,24 +26327,24 @@ var Resolver = class {
     }
     if (coinInfo.prefix != null) {
       const length = bytes[1];
-      let version28 = bytes[0];
-      if (version28 === 0) {
+      let version27 = bytes[0];
+      if (version27 === 0) {
         if (length !== 20 && length !== 32) {
-          version28 = -1;
+          version27 = -1;
         }
       } else {
-        version28 = -1;
+        version27 = -1;
       }
-      if (version28 >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
+      if (version27 >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
         const words2 = bech32.toWords(bytes.slice(2));
-        words2.unshift(version28);
+        words2.unshift(version27);
         return bech32.encode(coinInfo.prefix, words2);
       }
     }
     return null;
   }
   getAddress(coinType) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       if (coinType == null) {
         coinType = 60;
       }
@@ -24770,7 +26368,7 @@ var Resolver = class {
       }
       const address = this._getAddress(coinType, hexBytes);
       if (address == null) {
-        logger31.throwError(`invalid or unsupported coin data`, Logger.errors.UNSUPPORTED_OPERATION, {
+        logger30.throwError(`invalid or unsupported coin data`, Logger.errors.UNSUPPORTED_OPERATION, {
           operation: `getAddress(${coinType})`,
           coinType,
           data: hexBytes
@@ -24780,7 +26378,7 @@ var Resolver = class {
     });
   }
   getAvatar() {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       const linkage = [{ type: "name", content: this.name }];
       try {
         const avatar = yield this.getText("avatar");
@@ -24879,7 +26477,7 @@ var Resolver = class {
     });
   }
   getContentHash() {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       const hexBytes = yield this._fetchBytes("0xbc1c58d1");
       if (hexBytes == null || hexBytes === "0x") {
         return null;
@@ -24912,14 +26510,14 @@ var Resolver = class {
           return "sia://" + hash3;
         }
       }
-      return logger31.throwError(`invalid or unsupported content hash data`, Logger.errors.UNSUPPORTED_OPERATION, {
+      return logger30.throwError(`invalid or unsupported content hash data`, Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "getContentHash()",
         data: hexBytes
       });
     });
   }
   getText(key2) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       let keyBytes = toUtf8Bytes(key2);
       keyBytes = concat([bytes32ify(64), bytes32ify(keyBytes.length), keyBytes]);
       if (keyBytes.length % 32 !== 0) {
@@ -24967,7 +26565,7 @@ var BaseProvider = class extends Provider {
         defineReadOnly(this, "_network", knownNetwork);
         this.emit("network", knownNetwork, null);
       } else {
-        logger31.throwArgumentError("invalid network", "network", network);
+        logger30.throwArgumentError("invalid network", "network", network);
       }
     }
     this._maxInternalBlockNumber = -1024;
@@ -24977,7 +26575,7 @@ var BaseProvider = class extends Provider {
     this._fastQueryDate = 0;
   }
   _ready() {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       if (this._network == null) {
         let network = null;
         if (this._networkPromise) {
@@ -24990,7 +26588,7 @@ var BaseProvider = class extends Provider {
           network = yield this.detectNetwork();
         }
         if (!network) {
-          logger31.throwError("no network detected", Logger.errors.UNKNOWN_ERROR, {});
+          logger30.throwError("no network detected", Logger.errors.UNKNOWN_ERROR, {});
         }
         if (this._network == null) {
           if (this.anyNetwork) {
@@ -25031,7 +26629,7 @@ var BaseProvider = class extends Provider {
     return getNetwork(network == null ? "homestead" : network);
   }
   ccipReadFetch(tx, calldata, urls) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       if (this.disableCcipRead || urls.length === 0) {
         return null;
       }
@@ -25051,11 +26649,11 @@ var BaseProvider = class extends Provider {
         }
         const errorMessage = result.message || "unknown error";
         if (result.status >= 400 && result.status < 500) {
-          return logger31.throwError(`response not found during CCIP fetch: ${errorMessage}`, Logger.errors.SERVER_ERROR, { url, errorMessage });
+          return logger30.throwError(`response not found during CCIP fetch: ${errorMessage}`, Logger.errors.SERVER_ERROR, { url, errorMessage });
         }
         errorMessages.push(errorMessage);
       }
-      return logger31.throwError(`error encountered during CCIP fetch: ${errorMessages.map((m) => JSON.stringify(m)).join(", ")}`, Logger.errors.SERVER_ERROR, {
+      return logger30.throwError(`error encountered during CCIP fetch: ${errorMessages.map((m) => JSON.stringify(m)).join(", ")}`, Logger.errors.SERVER_ERROR, {
         urls,
         errorMessages
       });
@@ -25064,7 +26662,7 @@ var BaseProvider = class extends Provider {
   // Fetches the blockNumber, but will reuse any result that is less
   // than maxAge old or has been requested since the last request
   _getInternalBlockNumber(maxAge) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this._ready();
       if (maxAge > 0) {
         while (this._internalBlockNumber) {
@@ -25112,7 +26710,7 @@ var BaseProvider = class extends Provider {
     });
   }
   poll() {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       const pollId = nextPollId++;
       const runners = [];
       let blockNumber = null;
@@ -25132,8 +26730,8 @@ var BaseProvider = class extends Provider {
         this._emitted.block = blockNumber - 1;
       }
       if (Math.abs(this._emitted.block - blockNumber) > 1e3) {
-        logger31.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);
-        this.emit("error", logger31.makeError("network block skew detected", Logger.errors.NETWORK_ERROR, {
+        logger30.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);
+        this.emit("error", logger30.makeError("network block skew detected", Logger.errors.NETWORK_ERROR, {
           blockNumber,
           event: "blockSkew",
           previousBlockNumber: this._emitted.block
@@ -25240,14 +26838,14 @@ var BaseProvider = class extends Provider {
   // This method should query the network if the underlying network
   // can change, such as when connected to a JSON-RPC backend
   detectNetwork() {
-    return __awaiter11(this, void 0, void 0, function* () {
-      return logger31.throwError("provider does not support network detection", Logger.errors.UNSUPPORTED_OPERATION, {
+    return __awaiter10(this, void 0, void 0, function* () {
+      return logger30.throwError("provider does not support network detection", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "provider.detectNetwork"
       });
     });
   }
   getNetwork() {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       const network = yield this._ready();
       const currentNetwork = yield this.detectNetwork();
       if (network.chainId !== currentNetwork.chainId) {
@@ -25264,7 +26862,7 @@ var BaseProvider = class extends Provider {
           yield stall(0);
           return this._network;
         }
-        const error = logger31.makeError("underlying network changed", Logger.errors.NETWORK_ERROR, {
+        const error = logger30.makeError("underlying network changed", Logger.errors.NETWORK_ERROR, {
           event: "changed",
           network,
           detectedNetwork: currentNetwork
@@ -25345,12 +26943,12 @@ var BaseProvider = class extends Provider {
     }
   }
   waitForTransaction(transactionHash, confirmations, timeout) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       return this._waitForTransaction(transactionHash, confirmations == null ? 1 : confirmations, timeout || 0, null);
     });
   }
   _waitForTransaction(transactionHash, confirmations, timeout, replaceable) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       const receipt = yield this.getTransactionReceipt(transactionHash);
       if ((receipt ? receipt.confirmations : 0) >= confirmations) {
         return receipt;
@@ -25384,12 +26982,12 @@ var BaseProvider = class extends Provider {
         if (replaceable) {
           let lastBlockNumber = replaceable.startBlock;
           let scannedBlock = null;
-          const replaceHandler = (blockNumber) => __awaiter11(this, void 0, void 0, function* () {
+          const replaceHandler = (blockNumber) => __awaiter10(this, void 0, void 0, function* () {
             if (done) {
               return;
             }
             yield stall(1e3);
-            this.getTransactionCount(replaceable.from).then((nonce) => __awaiter11(this, void 0, void 0, function* () {
+            this.getTransactionCount(replaceable.from).then((nonce) => __awaiter10(this, void 0, void 0, function* () {
               if (done) {
                 return;
               }
@@ -25432,7 +27030,7 @@ var BaseProvider = class extends Provider {
                       } else if (tx.data === "0x" && tx.from === tx.to && tx.value.isZero()) {
                         reason = "cancelled";
                       }
-                      reject(logger31.makeError("transaction was replaced", Logger.errors.TRANSACTION_REPLACED, {
+                      reject(logger30.makeError("transaction was replaced", Logger.errors.TRANSACTION_REPLACED, {
                         cancelled: reason === "replaced" || reason === "cancelled",
                         reason,
                         replacement: this._wrapTransaction(tx),
@@ -25469,7 +27067,7 @@ var BaseProvider = class extends Provider {
             if (alreadyDone()) {
               return;
             }
-            reject(logger31.makeError("timeout exceeded", Logger.errors.TIMEOUT, { timeout }));
+            reject(logger30.makeError("timeout exceeded", Logger.errors.TIMEOUT, { timeout }));
           }, timeout);
           if (timer2.unref) {
             timer2.unref();
@@ -25482,18 +27080,18 @@ var BaseProvider = class extends Provider {
     });
   }
   getBlockNumber() {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       return this._getInternalBlockNumber(0);
     });
   }
   getGasPrice() {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const result = yield this.perform("getGasPrice", {});
       try {
         return BigNumber.from(result);
       } catch (error) {
-        return logger31.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
+        return logger30.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
           method: "getGasPrice",
           result,
           error
@@ -25502,7 +27100,7 @@ var BaseProvider = class extends Provider {
     });
   }
   getBalance(addressOrName, blockTag) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const params = yield resolveProperties({
         address: this._getAddress(addressOrName),
@@ -25512,7 +27110,7 @@ var BaseProvider = class extends Provider {
       try {
         return BigNumber.from(result);
       } catch (error) {
-        return logger31.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
+        return logger30.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
           method: "getBalance",
           params,
           result,
@@ -25522,7 +27120,7 @@ var BaseProvider = class extends Provider {
     });
   }
   getTransactionCount(addressOrName, blockTag) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const params = yield resolveProperties({
         address: this._getAddress(addressOrName),
@@ -25532,7 +27130,7 @@ var BaseProvider = class extends Provider {
       try {
         return BigNumber.from(result).toNumber();
       } catch (error) {
-        return logger31.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
+        return logger30.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
           method: "getTransactionCount",
           params,
           result,
@@ -25542,7 +27140,7 @@ var BaseProvider = class extends Provider {
     });
   }
   getCode(addressOrName, blockTag) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const params = yield resolveProperties({
         address: this._getAddress(addressOrName),
@@ -25552,7 +27150,7 @@ var BaseProvider = class extends Provider {
       try {
         return hexlify(result);
       } catch (error) {
-        return logger31.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
+        return logger30.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
           method: "getCode",
           params,
           result,
@@ -25562,7 +27160,7 @@ var BaseProvider = class extends Provider {
     });
   }
   getStorageAt(addressOrName, position, blockTag) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const params = yield resolveProperties({
         address: this._getAddress(addressOrName),
@@ -25573,7 +27171,7 @@ var BaseProvider = class extends Provider {
       try {
         return hexlify(result);
       } catch (error) {
-        return logger31.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
+        return logger30.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
           method: "getStorageAt",
           params,
           result,
@@ -25589,9 +27187,9 @@ var BaseProvider = class extends Provider {
     }
     const result = tx;
     if (hash3 != null && tx.hash !== hash3) {
-      logger31.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash3 });
+      logger30.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash3 });
     }
-    result.wait = (confirms, timeout) => __awaiter11(this, void 0, void 0, function* () {
+    result.wait = (confirms, timeout) => __awaiter10(this, void 0, void 0, function* () {
       if (confirms == null) {
         confirms = 1;
       }
@@ -25615,7 +27213,7 @@ var BaseProvider = class extends Provider {
       }
       this._emitted["t:" + tx.hash] = receipt.blockNumber;
       if (receipt.status === 0) {
-        logger31.throwError("transaction failed", Logger.errors.CALL_EXCEPTION, {
+        logger30.throwError("transaction failed", Logger.errors.CALL_EXCEPTION, {
           transactionHash: tx.hash,
           transaction: tx,
           receipt
@@ -25626,7 +27224,7 @@ var BaseProvider = class extends Provider {
     return result;
   }
   sendTransaction(signedTransaction) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const hexTx = yield Promise.resolve(signedTransaction).then((t) => hexlify(t));
       const tx = this.formatter.transaction(signedTransaction);
@@ -25645,7 +27243,7 @@ var BaseProvider = class extends Provider {
     });
   }
   _getTransactionRequest(transaction) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       const values = yield transaction;
       const tx = {};
       ["from", "to"].forEach((key2) => {
@@ -25679,7 +27277,7 @@ var BaseProvider = class extends Provider {
     });
   }
   _getFilter(filter) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       filter = yield filter;
       const result = {};
       if (filter.address != null) {
@@ -25701,9 +27299,9 @@ var BaseProvider = class extends Provider {
     });
   }
   _call(transaction, blockTag, attempt) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       if (attempt >= MAX_CCIP_REDIRECTS) {
-        logger31.throwError("CCIP read exceeded maximum redirections", Logger.errors.SERVER_ERROR, {
+        logger30.throwError("CCIP read exceeded maximum redirections", Logger.errors.SERVER_ERROR, {
           redirects: attempt,
           transaction
         });
@@ -25715,7 +27313,7 @@ var BaseProvider = class extends Provider {
           const data = hexDataSlice(result, 4);
           const sender = hexDataSlice(data, 0, 32);
           if (!BigNumber.from(sender).eq(txSender)) {
-            logger31.throwError("CCIP Read sender did not match", Logger.errors.CALL_EXCEPTION, {
+            logger30.throwError("CCIP Read sender did not match", Logger.errors.CALL_EXCEPTION, {
               name: "OffchainLookup",
               signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
               transaction,
@@ -25729,7 +27327,7 @@ var BaseProvider = class extends Provider {
           for (let u = 0; u < urlsLength; u++) {
             const url = _parseString(urlsData, u * 32);
             if (url == null) {
-              logger31.throwError("CCIP Read contained corrupt URL string", Logger.errors.CALL_EXCEPTION, {
+              logger30.throwError("CCIP Read contained corrupt URL string", Logger.errors.CALL_EXCEPTION, {
                 name: "OffchainLookup",
                 signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
                 transaction,
@@ -25740,7 +27338,7 @@ var BaseProvider = class extends Provider {
           }
           const calldata = _parseBytes(data, 64);
           if (!BigNumber.from(hexDataSlice(data, 100, 128)).isZero()) {
-            logger31.throwError("CCIP Read callback selector included junk", Logger.errors.CALL_EXCEPTION, {
+            logger30.throwError("CCIP Read callback selector included junk", Logger.errors.CALL_EXCEPTION, {
               name: "OffchainLookup",
               signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
               transaction,
@@ -25751,7 +27349,7 @@ var BaseProvider = class extends Provider {
           const extraData = _parseBytes(data, 128);
           const ccipResult = yield this.ccipReadFetch(transaction, calldata, urls);
           if (ccipResult == null) {
-            logger31.throwError("CCIP Read disabled or provided no URLs", Logger.errors.CALL_EXCEPTION, {
+            logger30.throwError("CCIP Read disabled or provided no URLs", Logger.errors.CALL_EXCEPTION, {
               name: "OffchainLookup",
               signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
               transaction,
@@ -25772,7 +27370,7 @@ var BaseProvider = class extends Provider {
       try {
         return hexlify(result);
       } catch (error) {
-        return logger31.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
+        return logger30.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
           method: "call",
           params: { transaction, blockTag },
           result,
@@ -25782,7 +27380,7 @@ var BaseProvider = class extends Provider {
     });
   }
   call(transaction, blockTag) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const resolved = yield resolveProperties({
         transaction: this._getTransactionRequest(transaction),
@@ -25793,7 +27391,7 @@ var BaseProvider = class extends Provider {
     });
   }
   estimateGas(transaction) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const params = yield resolveProperties({
         transaction: this._getTransactionRequest(transaction)
@@ -25802,7 +27400,7 @@ var BaseProvider = class extends Provider {
       try {
         return BigNumber.from(result);
       } catch (error) {
-        return logger31.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
+        return logger30.throwError("bad result from backend", Logger.errors.SERVER_ERROR, {
           method: "estimateGas",
           params,
           result,
@@ -25812,14 +27410,14 @@ var BaseProvider = class extends Provider {
     });
   }
   _getAddress(addressOrName) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       addressOrName = yield addressOrName;
       if (typeof addressOrName !== "string") {
-        logger31.throwArgumentError("invalid address or ENS name", "name", addressOrName);
+        logger30.throwArgumentError("invalid address or ENS name", "name", addressOrName);
       }
       const address = yield this.resolveName(addressOrName);
       if (address == null) {
-        logger31.throwError("ENS name not configured", Logger.errors.UNSUPPORTED_OPERATION, {
+        logger30.throwError("ENS name not configured", Logger.errors.UNSUPPORTED_OPERATION, {
           operation: `resolveName(${JSON.stringify(addressOrName)})`
         });
       }
@@ -25827,7 +27425,7 @@ var BaseProvider = class extends Provider {
     });
   }
   _getBlock(blockHashOrBlockTag, includeTransactions) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       blockHashOrBlockTag = yield blockHashOrBlockTag;
       let blockNumber = -128;
@@ -25843,10 +27441,10 @@ var BaseProvider = class extends Provider {
             blockNumber = parseInt(params.blockTag.substring(2), 16);
           }
         } catch (error) {
-          logger31.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
+          logger30.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
         }
       }
-      return poll(() => __awaiter11(this, void 0, void 0, function* () {
+      return poll(() => __awaiter10(this, void 0, void 0, function* () {
         const block = yield this.perform("getBlock", params);
         if (block == null) {
           if (params.blockHash != null) {
@@ -25893,11 +27491,11 @@ var BaseProvider = class extends Provider {
     return this._getBlock(blockHashOrBlockTag, true);
   }
   getTransaction(transactionHash) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       transactionHash = yield transactionHash;
       const params = { transactionHash: this.formatter.hash(transactionHash, true) };
-      return poll(() => __awaiter11(this, void 0, void 0, function* () {
+      return poll(() => __awaiter10(this, void 0, void 0, function* () {
         const result = yield this.perform("getTransaction", params);
         if (result == null) {
           if (this._emitted["t:" + transactionHash] == null) {
@@ -25921,11 +27519,11 @@ var BaseProvider = class extends Provider {
     });
   }
   getTransactionReceipt(transactionHash) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       transactionHash = yield transactionHash;
       const params = { transactionHash: this.formatter.hash(transactionHash, true) };
-      return poll(() => __awaiter11(this, void 0, void 0, function* () {
+      return poll(() => __awaiter10(this, void 0, void 0, function* () {
         const result = yield this.perform("getTransactionReceipt", params);
         if (result == null) {
           if (this._emitted["t:" + transactionHash] == null) {
@@ -25952,7 +27550,7 @@ var BaseProvider = class extends Provider {
     });
   }
   getLogs(filter) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       const params = yield resolveProperties({ filter: this._getFilter(filter) });
       const logs = yield this.perform("getLogs", params);
@@ -25965,17 +27563,17 @@ var BaseProvider = class extends Provider {
     });
   }
   getEtherPrice() {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       yield this.getNetwork();
       return this.perform("getEtherPrice", {});
     });
   }
   _getBlockTag(blockTag) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       blockTag = yield blockTag;
       if (typeof blockTag === "number" && blockTag < 0) {
         if (blockTag % 1) {
-          logger31.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
+          logger30.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
         }
         let blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
         blockNumber += blockTag;
@@ -25988,7 +27586,7 @@ var BaseProvider = class extends Provider {
     });
   }
   getResolver(name) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       let currentName = name;
       while (true) {
         if (currentName === "" || currentName === ".") {
@@ -26010,13 +27608,13 @@ var BaseProvider = class extends Provider {
     });
   }
   _getResolver(name, operation) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       if (operation == null) {
         operation = "ENS";
       }
       const network = yield this.getNetwork();
       if (!network.ensAddress) {
-        logger31.throwError("network does not support ENS", Logger.errors.UNSUPPORTED_OPERATION, { operation, network: network.name });
+        logger30.throwError("network does not support ENS", Logger.errors.UNSUPPORTED_OPERATION, { operation, network: network.name });
       }
       try {
         const addrData = yield this.call({
@@ -26030,7 +27628,7 @@ var BaseProvider = class extends Provider {
     });
   }
   resolveName(name) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       name = yield name;
       try {
         return Promise.resolve(this.formatter.address(name));
@@ -26040,7 +27638,7 @@ var BaseProvider = class extends Provider {
         }
       }
       if (typeof name !== "string") {
-        logger31.throwArgumentError("invalid ENS name", "name", name);
+        logger30.throwArgumentError("invalid ENS name", "name", name);
       }
       const resolver = yield this.getResolver(name);
       if (!resolver) {
@@ -26050,7 +27648,7 @@ var BaseProvider = class extends Provider {
     });
   }
   lookupAddress(address) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       address = yield address;
       address = this.formatter.address(address);
       const node = address.substring(2).toLowerCase() + ".addr.reverse";
@@ -26070,7 +27668,7 @@ var BaseProvider = class extends Provider {
     });
   }
   getAvatar(nameOrAddress) {
-    return __awaiter11(this, void 0, void 0, function* () {
+    return __awaiter10(this, void 0, void 0, function* () {
       let resolver = null;
       if (isHexString(nameOrAddress)) {
         const address = this.formatter.address(nameOrAddress);
@@ -26116,7 +27714,7 @@ var BaseProvider = class extends Provider {
     });
   }
   perform(method, params) {
-    return logger31.throwError(method + " not implemented", Logger.errors.NOT_IMPLEMENTED, { operation: method });
+    return logger30.throwError(method + " not implemented", Logger.errors.NOT_IMPLEMENTED, { operation: method });
   }
   _startEvent(event) {
     this.polling = this._events.filter((e) => e.pollable()).length > 0;
@@ -26220,8 +27818,8 @@ var BaseProvider = class extends Provider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/json-rpc-provider.js
-var __awaiter12 = function(thisArg, _arguments, P, generator) {
+// node_modules/@ethersproject/providers/lib.esm/json-rpc-provider.js
+var __awaiter11 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -26248,7 +27846,7 @@ var __awaiter12 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger32 = new Logger(version24);
+var logger31 = new Logger(version23);
 var errorGas = ["call", "estimateGas"];
 function spelunk(value, requireData) {
   if (value == null) {
@@ -26284,7 +27882,7 @@ function checkError(method, error, params) {
     if (result) {
       return result.data;
     }
-    logger32.throwError("missing revert data in call exception; Transaction reverted without a reason string", Logger.errors.CALL_EXCEPTION, {
+    logger31.throwError("missing revert data in call exception; Transaction reverted without a reason string", Logger.errors.CALL_EXCEPTION, {
       data: "0x",
       transaction,
       error
@@ -26296,7 +27894,7 @@ function checkError(method, error, params) {
       result = spelunk(error, false);
     }
     if (result) {
-      logger32.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
+      logger31.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
         reason: result.message,
         method,
         transaction,
@@ -26314,35 +27912,35 @@ function checkError(method, error, params) {
   }
   message = (message || "").toLowerCase();
   if (message.match(/insufficient funds|base fee exceeds gas limit|InsufficientFunds/i)) {
-    logger32.throwError("insufficient funds for intrinsic transaction cost", Logger.errors.INSUFFICIENT_FUNDS, {
+    logger31.throwError("insufficient funds for intrinsic transaction cost", Logger.errors.INSUFFICIENT_FUNDS, {
       error,
       method,
       transaction
     });
   }
   if (message.match(/nonce (is )?too low/i)) {
-    logger32.throwError("nonce has already been used", Logger.errors.NONCE_EXPIRED, {
+    logger31.throwError("nonce has already been used", Logger.errors.NONCE_EXPIRED, {
       error,
       method,
       transaction
     });
   }
   if (message.match(/replacement transaction underpriced|transaction gas price.*too low/i)) {
-    logger32.throwError("replacement fee too low", Logger.errors.REPLACEMENT_UNDERPRICED, {
+    logger31.throwError("replacement fee too low", Logger.errors.REPLACEMENT_UNDERPRICED, {
       error,
       method,
       transaction
     });
   }
   if (message.match(/only replay-protected/i)) {
-    logger32.throwError("legacy pre-eip-155 transactions not supported", Logger.errors.UNSUPPORTED_OPERATION, {
+    logger31.throwError("legacy pre-eip-155 transactions not supported", Logger.errors.UNSUPPORTED_OPERATION, {
       error,
       method,
       transaction
     });
   }
   if (errorGas.indexOf(method) >= 0 && message.match(/gas required exceeds allowance|always failing transaction|execution reverted|revert/)) {
-    logger32.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
+    logger31.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
       error,
       method,
       transaction
@@ -26388,11 +27986,11 @@ var JsonRpcSigner = class extends Signer {
       defineReadOnly(this, "_index", addressOrIndex);
       defineReadOnly(this, "_address", null);
     } else {
-      logger32.throwArgumentError("invalid address or index", "addressOrIndex", addressOrIndex);
+      logger31.throwArgumentError("invalid address or index", "addressOrIndex", addressOrIndex);
     }
   }
   connect(provider) {
-    return logger32.throwError("cannot alter JSON-RPC Signer connection", Logger.errors.UNSUPPORTED_OPERATION, {
+    return logger31.throwError("cannot alter JSON-RPC Signer connection", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "connect"
     });
   }
@@ -26405,7 +28003,7 @@ var JsonRpcSigner = class extends Signer {
     }
     return this.provider.send("eth_accounts", []).then((accounts) => {
       if (accounts.length <= this._index) {
-        logger32.throwError("unknown account #" + this._index, Logger.errors.UNSUPPORTED_OPERATION, {
+        logger31.throwError("unknown account #" + this._index, Logger.errors.UNSUPPORTED_OPERATION, {
           operation: "getAddress"
         });
       }
@@ -26426,13 +28024,13 @@ var JsonRpcSigner = class extends Signer {
       transaction.gasLimit = this.provider.estimateGas(estimate);
     }
     if (transaction.to != null) {
-      transaction.to = Promise.resolve(transaction.to).then((to) => __awaiter12(this, void 0, void 0, function* () {
+      transaction.to = Promise.resolve(transaction.to).then((to) => __awaiter11(this, void 0, void 0, function* () {
         if (to == null) {
           return null;
         }
         const address = yield this.provider.resolveName(to);
         if (address == null) {
-          logger32.throwArgumentError("provided ENS name resolves to null", "tx.to", to);
+          logger31.throwArgumentError("provided ENS name resolves to null", "tx.to", to);
         }
         return address;
       }));
@@ -26443,7 +28041,7 @@ var JsonRpcSigner = class extends Signer {
     }).then(({ tx, sender }) => {
       if (tx.from != null) {
         if (tx.from.toLowerCase() !== sender) {
-          logger32.throwArgumentError("from address mismatch", "transaction", transaction);
+          logger31.throwArgumentError("from address mismatch", "transaction", transaction);
         }
       } else {
         tx.from = sender;
@@ -26453,7 +28051,7 @@ var JsonRpcSigner = class extends Signer {
         return hash3;
       }, (error) => {
         if (typeof error.message === "string" && error.message.match(/user denied/i)) {
-          logger32.throwError("user rejected transaction", Logger.errors.ACTION_REJECTED, {
+          logger31.throwError("user rejected transaction", Logger.errors.ACTION_REJECTED, {
             action: "sendTransaction",
             transaction: tx
           });
@@ -26463,16 +28061,16 @@ var JsonRpcSigner = class extends Signer {
     });
   }
   signTransaction(transaction) {
-    return logger32.throwError("signing transactions is unsupported", Logger.errors.UNSUPPORTED_OPERATION, {
+    return logger31.throwError("signing transactions is unsupported", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "signTransaction"
     });
   }
   sendTransaction(transaction) {
-    return __awaiter12(this, void 0, void 0, function* () {
+    return __awaiter11(this, void 0, void 0, function* () {
       const blockNumber = yield this.provider._getInternalBlockNumber(100 + 2 * this.provider.pollingInterval);
       const hash3 = yield this.sendUncheckedTransaction(transaction);
       try {
-        return yield poll(() => __awaiter12(this, void 0, void 0, function* () {
+        return yield poll(() => __awaiter11(this, void 0, void 0, function* () {
           const tx = yield this.provider.getTransaction(hash3);
           if (tx === null) {
             return void 0;
@@ -26486,14 +28084,14 @@ var JsonRpcSigner = class extends Signer {
     });
   }
   signMessage(message) {
-    return __awaiter12(this, void 0, void 0, function* () {
+    return __awaiter11(this, void 0, void 0, function* () {
       const data = typeof message === "string" ? toUtf8Bytes(message) : message;
       const address = yield this.getAddress();
       try {
         return yield this.provider.send("personal_sign", [hexlify(data), address.toLowerCase()]);
       } catch (error) {
         if (typeof error.message === "string" && error.message.match(/user denied/i)) {
-          logger32.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
+          logger31.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
             action: "signMessage",
             from: address,
             messageData: message
@@ -26504,14 +28102,14 @@ var JsonRpcSigner = class extends Signer {
     });
   }
   _legacySignMessage(message) {
-    return __awaiter12(this, void 0, void 0, function* () {
+    return __awaiter11(this, void 0, void 0, function* () {
       const data = typeof message === "string" ? toUtf8Bytes(message) : message;
       const address = yield this.getAddress();
       try {
         return yield this.provider.send("eth_sign", [address.toLowerCase(), hexlify(data)]);
       } catch (error) {
         if (typeof error.message === "string" && error.message.match(/user denied/i)) {
-          logger32.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
+          logger31.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
             action: "_legacySignMessage",
             from: address,
             messageData: message
@@ -26522,7 +28120,7 @@ var JsonRpcSigner = class extends Signer {
     });
   }
   _signTypedData(domain, types, value) {
-    return __awaiter12(this, void 0, void 0, function* () {
+    return __awaiter11(this, void 0, void 0, function* () {
       const populated = yield TypedDataEncoder.resolveNames(domain, types, value, (name) => {
         return this.provider.resolveName(name);
       });
@@ -26534,7 +28132,7 @@ var JsonRpcSigner = class extends Signer {
         ]);
       } catch (error) {
         if (typeof error.message === "string" && error.message.match(/user denied/i)) {
-          logger32.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
+          logger31.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
             action: "_signTypedData",
             from: address,
             messageData: { domain: populated.domain, types, value: populated.value }
@@ -26545,7 +28143,7 @@ var JsonRpcSigner = class extends Signer {
     });
   }
   unlock(password) {
-    return __awaiter12(this, void 0, void 0, function* () {
+    return __awaiter11(this, void 0, void 0, function* () {
       const provider = this.provider;
       const address = yield this.getAddress();
       return provider.send("personal_unlockAccount", [address.toLowerCase(), password, null]);
@@ -26631,7 +28229,7 @@ var JsonRpcProvider = class extends BaseProvider {
     return this._cache["detectNetwork"];
   }
   _uncachedDetectNetwork() {
-    return __awaiter12(this, void 0, void 0, function* () {
+    return __awaiter11(this, void 0, void 0, function* () {
       yield timer(0);
       let chainId = null;
       try {
@@ -26647,14 +28245,14 @@ var JsonRpcProvider = class extends BaseProvider {
         try {
           return getNetwork2(BigNumber.from(chainId).toNumber());
         } catch (error) {
-          return logger32.throwError("could not detect network", Logger.errors.NETWORK_ERROR, {
+          return logger31.throwError("could not detect network", Logger.errors.NETWORK_ERROR, {
             chainId,
             event: "invalidNetwork",
             serverError: error
           });
         }
       }
-      return logger32.throwError("could not detect network", Logger.errors.NETWORK_ERROR, {
+      return logger31.throwError("could not detect network", Logger.errors.NETWORK_ERROR, {
         event: "noNetwork"
       });
     });
@@ -26757,7 +28355,7 @@ var JsonRpcProvider = class extends BaseProvider {
     return null;
   }
   perform(method, params) {
-    return __awaiter12(this, void 0, void 0, function* () {
+    return __awaiter11(this, void 0, void 0, function* () {
       if (method === "call" || method === "estimateGas") {
         const tx = params.transaction;
         if (tx && tx.type != null && BigNumber.from(tx.type).isZero()) {
@@ -26773,7 +28371,7 @@ var JsonRpcProvider = class extends BaseProvider {
       }
       const args = this.prepareRequest(method, params);
       if (args == null) {
-        logger32.throwError(method + " not implemented", Logger.errors.NOT_IMPLEMENTED, { operation: method });
+        logger31.throwError(method + " not implemented", Logger.errors.NOT_IMPLEMENTED, { operation: method });
       }
       try {
         return yield this.send(args[0], args[1]);
@@ -26880,7 +28478,7 @@ var JsonRpcProvider = class extends BaseProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/ws.js
+// node_modules/@ethersproject/providers/lib.esm/ws.js
 var WS = null;
 try {
   WS = WebSocket;
@@ -26888,16 +28486,16 @@ try {
     throw new Error("inject please");
   }
 } catch (error) {
-  const logger49 = new Logger(version24);
+  const logger48 = new Logger(version23);
   WS = function() {
-    logger49.throwError("WebSockets not supported in this environment", Logger.errors.UNSUPPORTED_OPERATION, {
+    logger48.throwError("WebSockets not supported in this environment", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "new WebSocket()"
     });
   };
 }
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/websocket-provider.js
-var __awaiter13 = function(thisArg, _arguments, P, generator) {
+// node_modules/@ethersproject/providers/lib.esm/websocket-provider.js
+var __awaiter12 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -26924,12 +28522,12 @@ var __awaiter13 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger33 = new Logger(version24);
+var logger32 = new Logger(version23);
 var NextId = 1;
 var WebSocketProvider = class extends JsonRpcProvider {
   constructor(url, network) {
     if (network === "any") {
-      logger33.throwError("WebSocketProvider does not support 'any' network yet", Logger.errors.UNSUPPORTED_OPERATION, {
+      logger32.throwError("WebSocketProvider does not support 'any' network yet", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "network:any"
       });
     }
@@ -27015,17 +28613,17 @@ var WebSocketProvider = class extends JsonRpcProvider {
     return 0;
   }
   resetEventsBlock(blockNumber) {
-    logger33.throwError("cannot reset events block on WebSocketProvider", Logger.errors.UNSUPPORTED_OPERATION, {
+    logger32.throwError("cannot reset events block on WebSocketProvider", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "resetEventBlock"
     });
   }
   set pollingInterval(value) {
-    logger33.throwError("cannot set polling interval on WebSocketProvider", Logger.errors.UNSUPPORTED_OPERATION, {
+    logger32.throwError("cannot set polling interval on WebSocketProvider", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "setPollingInterval"
     });
   }
   poll() {
-    return __awaiter13(this, void 0, void 0, function* () {
+    return __awaiter12(this, void 0, void 0, function* () {
       return null;
     });
   }
@@ -27033,7 +28631,7 @@ var WebSocketProvider = class extends JsonRpcProvider {
     if (!value) {
       return;
     }
-    logger33.throwError("cannot set polling on WebSocketProvider", Logger.errors.UNSUPPORTED_OPERATION, {
+    logger32.throwError("cannot set polling on WebSocketProvider", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "setPolling"
     });
   }
@@ -27067,7 +28665,7 @@ var WebSocketProvider = class extends JsonRpcProvider {
     return "ws://localhost:8546";
   }
   _subscribe(tag, param, processFunc) {
-    return __awaiter13(this, void 0, void 0, function* () {
+    return __awaiter12(this, void 0, void 0, function* () {
       let subIdPromise = this._subIds[tag];
       if (subIdPromise == null) {
         subIdPromise = Promise.all(param).then((param2) => {
@@ -27152,7 +28750,7 @@ var WebSocketProvider = class extends JsonRpcProvider {
     });
   }
   destroy() {
-    return __awaiter13(this, void 0, void 0, function* () {
+    return __awaiter12(this, void 0, void 0, function* () {
       if (this.websocket.readyState === WS.CONNECTING) {
         yield new Promise((resolve) => {
           this.websocket.onopen = function() {
@@ -27168,8 +28766,8 @@ var WebSocketProvider = class extends JsonRpcProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/url-json-rpc-provider.js
-var __awaiter14 = function(thisArg, _arguments, P, generator) {
+// node_modules/@ethersproject/providers/lib.esm/url-json-rpc-provider.js
+var __awaiter13 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -27196,18 +28794,18 @@ var __awaiter14 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger34 = new Logger(version24);
+var logger33 = new Logger(version23);
 var StaticJsonRpcProvider = class extends JsonRpcProvider {
   detectNetwork() {
     const _super = Object.create(null, {
       detectNetwork: { get: () => super.detectNetwork }
     });
-    return __awaiter14(this, void 0, void 0, function* () {
+    return __awaiter13(this, void 0, void 0, function* () {
       let network = this.network;
       if (network == null) {
         network = yield _super.detectNetwork.call(this);
         if (!network) {
-          logger34.throwError("no network detected", Logger.errors.UNKNOWN_ERROR, {});
+          logger33.throwError("no network detected", Logger.errors.UNKNOWN_ERROR, {});
         }
         if (this._network == null) {
           defineReadOnly(this, "_network", network);
@@ -27220,7 +28818,7 @@ var StaticJsonRpcProvider = class extends JsonRpcProvider {
 };
 var UrlJsonRpcProvider = class _UrlJsonRpcProvider extends StaticJsonRpcProvider {
   constructor(network, apiKey) {
-    logger34.checkAbstract(new.target, _UrlJsonRpcProvider);
+    logger33.checkAbstract(new.target, _UrlJsonRpcProvider);
     network = getStatic(new.target, "getNetwork")(network);
     apiKey = getStatic(new.target, "getApiKey")(apiKey);
     const connection = getStatic(new.target, "getUrl")(network, apiKey);
@@ -27234,13 +28832,13 @@ var UrlJsonRpcProvider = class _UrlJsonRpcProvider extends StaticJsonRpcProvider
     }
   }
   _startPending() {
-    logger34.warn("WARNING: API provider does not support pending filters");
+    logger33.warn("WARNING: API provider does not support pending filters");
   }
   isCommunityResource() {
     return false;
   }
   getSigner(address) {
-    return logger34.throwError("API provider does not support signing", Logger.errors.UNSUPPORTED_OPERATION, { operation: "getSigner" });
+    return logger33.throwError("API provider does not support signing", Logger.errors.UNSUPPORTED_OPERATION, { operation: "getSigner" });
   }
   listAccounts() {
     return Promise.resolve([]);
@@ -27253,14 +28851,14 @@ var UrlJsonRpcProvider = class _UrlJsonRpcProvider extends StaticJsonRpcProvider
   // API key will have been sanitized by the getApiKey first, so any validation
   // or transformations can be done there.
   static getUrl(network, apiKey) {
-    return logger34.throwError("not implemented; sub-classes must override getUrl", Logger.errors.NOT_IMPLEMENTED, {
+    return logger33.throwError("not implemented; sub-classes must override getUrl", Logger.errors.NOT_IMPLEMENTED, {
       operation: "getUrl"
     });
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/alchemy-provider.js
-var logger35 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/alchemy-provider.js
+var logger34 = new Logger(version23);
 var defaultApiKey = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC";
 var AlchemyWebSocketProvider = class extends WebSocketProvider {
   constructor(network, apiKey) {
@@ -27282,7 +28880,7 @@ var AlchemyProvider = class extends UrlJsonRpcProvider {
       return defaultApiKey;
     }
     if (apiKey && typeof apiKey !== "string") {
-      logger35.throwArgumentError("invalid apiKey", "apiKey", apiKey);
+      logger34.throwArgumentError("invalid apiKey", "apiKey", apiKey);
     }
     return apiKey;
   }
@@ -27323,7 +28921,7 @@ var AlchemyProvider = class extends UrlJsonRpcProvider {
         host = "opt-sepolia.g.alchemy.com/v2/";
         break;
       default:
-        logger35.throwArgumentError("unsupported network", "network", arguments[0]);
+        logger34.throwArgumentError("unsupported network", "network", arguments[0]);
     }
     return {
       allowGzip: true,
@@ -27341,8 +28939,8 @@ var AlchemyProvider = class extends UrlJsonRpcProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/ankr-provider.js
-var logger36 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/ankr-provider.js
+var logger35 = new Logger(version23);
 var defaultApiKey2 = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972";
 function getHost(name) {
   switch (name) {
@@ -27369,7 +28967,7 @@ function getHost(name) {
     case "arbitrum":
       return "rpc.ankr.com/arbitrum/";
   }
-  return logger36.throwArgumentError("unsupported network", "name", name);
+  return logger35.throwArgumentError("unsupported network", "name", name);
 }
 var AnkrProvider = class extends UrlJsonRpcProvider {
   isCommunityResource() {
@@ -27403,8 +29001,8 @@ var AnkrProvider = class extends UrlJsonRpcProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/cloudflare-provider.js
-var __awaiter15 = function(thisArg, _arguments, P, generator) {
+// node_modules/@ethersproject/providers/lib.esm/cloudflare-provider.js
+var __awaiter14 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -27431,11 +29029,11 @@ var __awaiter15 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger37 = new Logger(version24);
+var logger36 = new Logger(version23);
 var CloudflareProvider = class extends UrlJsonRpcProvider {
   static getApiKey(apiKey) {
     if (apiKey != null) {
-      logger37.throwArgumentError("apiKey not supported for cloudflare", "apiKey", apiKey);
+      logger36.throwArgumentError("apiKey not supported for cloudflare", "apiKey", apiKey);
     }
     return null;
   }
@@ -27446,7 +29044,7 @@ var CloudflareProvider = class extends UrlJsonRpcProvider {
         host = "https://cloudflare-eth.com/";
         break;
       default:
-        logger37.throwArgumentError("unsupported network", "network", arguments[0]);
+        logger36.throwArgumentError("unsupported network", "network", arguments[0]);
     }
     return host;
   }
@@ -27454,7 +29052,7 @@ var CloudflareProvider = class extends UrlJsonRpcProvider {
     const _super = Object.create(null, {
       perform: { get: () => super.perform }
     });
-    return __awaiter15(this, void 0, void 0, function* () {
+    return __awaiter14(this, void 0, void 0, function* () {
       if (method === "getBlockNumber") {
         const block = yield _super.perform.call(this, "getBlock", { blockTag: "latest" });
         return block.number;
@@ -27464,8 +29062,8 @@ var CloudflareProvider = class extends UrlJsonRpcProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/etherscan-provider.js
-var __awaiter16 = function(thisArg, _arguments, P, generator) {
+// node_modules/@ethersproject/providers/lib.esm/etherscan-provider.js
+var __awaiter15 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -27492,7 +29090,7 @@ var __awaiter16 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger38 = new Logger(version24);
+var logger37 = new Logger(version23);
 function getTransactionPostData(transaction) {
   const result = {};
   for (let key2 in transaction) {
@@ -27574,7 +29172,7 @@ function checkError2(method, error, transaction) {
       if (isHexString(data)) {
         return data;
       }
-      logger38.throwError("missing revert data in call exception", Logger.errors.CALL_EXCEPTION, {
+      logger37.throwError("missing revert data in call exception", Logger.errors.CALL_EXCEPTION, {
         error,
         data: "0x"
       });
@@ -27592,28 +29190,28 @@ function checkError2(method, error, transaction) {
   }
   message = (message || "").toLowerCase();
   if (message.match(/insufficient funds/)) {
-    logger38.throwError("insufficient funds for intrinsic transaction cost", Logger.errors.INSUFFICIENT_FUNDS, {
+    logger37.throwError("insufficient funds for intrinsic transaction cost", Logger.errors.INSUFFICIENT_FUNDS, {
       error,
       method,
       transaction
     });
   }
   if (message.match(/same hash was already imported|transaction nonce is too low|nonce too low/)) {
-    logger38.throwError("nonce has already been used", Logger.errors.NONCE_EXPIRED, {
+    logger37.throwError("nonce has already been used", Logger.errors.NONCE_EXPIRED, {
       error,
       method,
       transaction
     });
   }
   if (message.match(/another transaction with same nonce/)) {
-    logger38.throwError("replacement fee too low", Logger.errors.REPLACEMENT_UNDERPRICED, {
+    logger37.throwError("replacement fee too low", Logger.errors.REPLACEMENT_UNDERPRICED, {
       error,
       method,
       transaction
     });
   }
   if (message.match(/execution failed due to an exception|execution reverted/)) {
-    logger38.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
+    logger37.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
       error,
       method,
       transaction
@@ -27649,7 +29247,7 @@ var EtherscanProvider = class extends BaseProvider {
         return "https://api-goerli-optimistic.etherscan.io";
       default:
     }
-    return logger38.throwArgumentError("unsupported network", "network", this.network.name);
+    return logger37.throwArgumentError("unsupported network", "network", this.network.name);
   }
   getUrl(module, params) {
     const query = Object.keys(params).reduce((accum, key2) => {
@@ -27671,7 +29269,7 @@ var EtherscanProvider = class extends BaseProvider {
     return params;
   }
   fetch(module, params, post) {
-    return __awaiter16(this, void 0, void 0, function* () {
+    return __awaiter15(this, void 0, void 0, function* () {
       const url = post ? this.getPostUrl() : this.getUrl(module, params);
       const payload = post ? this.getPostData(module, params) : null;
       const procFunc = module === "proxy" ? getJsonResult : getResult2;
@@ -27708,7 +29306,7 @@ var EtherscanProvider = class extends BaseProvider {
     });
   }
   detectNetwork() {
-    return __awaiter16(this, void 0, void 0, function* () {
+    return __awaiter15(this, void 0, void 0, function* () {
       return this.network;
     });
   }
@@ -27716,7 +29314,7 @@ var EtherscanProvider = class extends BaseProvider {
     const _super = Object.create(null, {
       perform: { get: () => super.perform }
     });
-    return __awaiter16(this, void 0, void 0, function* () {
+    return __awaiter15(this, void 0, void 0, function* () {
       switch (method) {
         case "getBlockNumber":
           return this.fetch("proxy", { action: "eth_blockNumber" });
@@ -27809,12 +29407,12 @@ var EtherscanProvider = class extends BaseProvider {
           }
           if (params.filter.topics && params.filter.topics.length > 0) {
             if (params.filter.topics.length > 1) {
-              logger38.throwError("unsupported topic count", Logger.errors.UNSUPPORTED_OPERATION, { topics: params.filter.topics });
+              logger37.throwError("unsupported topic count", Logger.errors.UNSUPPORTED_OPERATION, { topics: params.filter.topics });
             }
             if (params.filter.topics.length === 1) {
               const topic0 = params.filter.topics[0];
               if (typeof topic0 !== "string" || topic0.length !== 66) {
-                logger38.throwError("unsupported topic format", Logger.errors.UNSUPPORTED_OPERATION, { topic0 });
+                logger37.throwError("unsupported topic format", Logger.errors.UNSUPPORTED_OPERATION, { topic0 });
               }
               args.topic0 = topic0;
             }
@@ -27852,7 +29450,7 @@ var EtherscanProvider = class extends BaseProvider {
   //       Error: Result window is too large, PageNo x Offset size must
   //              be less than or equal to 10000
   getHistory(addressOrName, startBlock, endBlock) {
-    return __awaiter16(this, void 0, void 0, function* () {
+    return __awaiter15(this, void 0, void 0, function* () {
       const params = {
         action: "txlist",
         address: yield this.resolveName(addressOrName),
@@ -27883,8 +29481,8 @@ var EtherscanProvider = class extends BaseProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/fallback-provider.js
-var __awaiter17 = function(thisArg, _arguments, P, generator) {
+// node_modules/@ethersproject/providers/lib.esm/fallback-provider.js
+var __awaiter16 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
@@ -27911,7 +29509,7 @@ var __awaiter17 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger39 = new Logger(version24);
+var logger38 = new Logger(version23);
 function now() {
   return (/* @__PURE__ */ new Date()).getTime();
 }
@@ -27924,7 +29522,7 @@ function checkNetworks(networks2) {
     }
     if (result) {
       if (!(result.name === network.name && result.chainId === network.chainId && (result.ensAddress === network.ensAddress || result.ensAddress == null && network.ensAddress == null))) {
-        logger39.throwArgumentError("provider mismatch", "networks", networks2);
+        logger38.throwArgumentError("provider mismatch", "networks", networks2);
       }
     } else {
       result = network;
@@ -28125,7 +29723,7 @@ function getProcessFunc(provider, method, params) {
   return normalizedTally(normalize2, provider.quorum);
 }
 function waitForSync(config, blockNumber) {
-  return __awaiter17(this, void 0, void 0, function* () {
+  return __awaiter16(this, void 0, void 0, function* () {
     const provider = config.provider;
     if (provider.blockNumber != null && provider.blockNumber >= blockNumber || blockNumber === -1) {
       return provider;
@@ -28146,7 +29744,7 @@ function waitForSync(config, blockNumber) {
   });
 }
 function getRunner(config, currentBlockNumber, method, params) {
-  return __awaiter17(this, void 0, void 0, function* () {
+  return __awaiter16(this, void 0, void 0, function* () {
     let provider = config.provider;
     switch (method) {
       case "getBlockNumber":
@@ -28194,7 +29792,7 @@ function getRunner(config, currentBlockNumber, method, params) {
         return provider.getLogs(filter);
       }
     }
-    return logger39.throwError("unknown method error", Logger.errors.UNKNOWN_ERROR, {
+    return logger38.throwError("unknown method error", Logger.errors.UNKNOWN_ERROR, {
       method,
       params
     });
@@ -28203,7 +29801,7 @@ function getRunner(config, currentBlockNumber, method, params) {
 var FallbackProvider = class extends BaseProvider {
   constructor(providers, quorum) {
     if (providers.length === 0) {
-      logger39.throwArgumentError("missing providers", "providers", providers);
+      logger38.throwArgumentError("missing providers", "providers", providers);
     }
     const providerConfigs = providers.map((configOrProvider, index) => {
       if (Provider.isProvider(configOrProvider)) {
@@ -28223,7 +29821,7 @@ var FallbackProvider = class extends BaseProvider {
       }
       const weight = config.weight;
       if (weight % 1 || weight > 512 || weight < 1) {
-        logger39.throwArgumentError("invalid weight; must be integer in [1, 512]", `providers[${index}].weight`, weight);
+        logger38.throwArgumentError("invalid weight; must be integer in [1, 512]", `providers[${index}].weight`, weight);
       }
       return Object.freeze(config);
     });
@@ -28231,7 +29829,7 @@ var FallbackProvider = class extends BaseProvider {
     if (quorum == null) {
       quorum = total / 2;
     } else if (quorum > total) {
-      logger39.throwArgumentError("quorum will always fail; larger than total weight", "quorum", quorum);
+      logger38.throwArgumentError("quorum will always fail; larger than total weight", "quorum", quorum);
     }
     let networkOrReady = checkNetworks(providerConfigs.map((c) => c.provider.network));
     if (networkOrReady == null) {
@@ -28247,13 +29845,13 @@ var FallbackProvider = class extends BaseProvider {
     this._highestBlockNumber = -1;
   }
   detectNetwork() {
-    return __awaiter17(this, void 0, void 0, function* () {
+    return __awaiter16(this, void 0, void 0, function* () {
       const networks2 = yield Promise.all(this.providerConfigs.map((c) => c.provider.getNetwork()));
       return checkNetworks(networks2);
     });
   }
   perform(method, params) {
-    return __awaiter17(this, void 0, void 0, function* () {
+    return __awaiter16(this, void 0, void 0, function* () {
       if (method === "sendTransaction") {
         const results = yield Promise.all(this.providerConfigs.map((c) => {
           return c.provider.sendTransaction(params.signedTransaction).then((result) => {
@@ -28388,7 +29986,7 @@ var FallbackProvider = class extends BaseProvider {
             }
             props[name] = e[name];
           });
-          logger39.throwError(e.reason || e.message, errorCode, props);
+          logger38.throwError(e.reason || e.message, errorCode, props);
         });
         if (configs.filter((c) => !c.done).length === 0) {
           break;
@@ -28400,7 +29998,7 @@ var FallbackProvider = class extends BaseProvider {
         }
         c.cancelled = true;
       });
-      return logger39.throwError("failed to meet quorum", Logger.errors.SERVER_ERROR, {
+      return logger38.throwError("failed to meet quorum", Logger.errors.SERVER_ERROR, {
         method,
         params,
         //results: configs.map((c) => c.result),
@@ -28412,18 +30010,18 @@ var FallbackProvider = class extends BaseProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/ipc-provider.js
+// node_modules/@ethersproject/providers/lib.esm/ipc-provider.js
 var IpcProvider = null;
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/infura-provider.js
-var logger40 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/infura-provider.js
+var logger39 = new Logger(version23);
 var defaultProjectId = "84842078b09946638c03157f83405213";
 var InfuraWebSocketProvider = class extends WebSocketProvider {
   constructor(network, apiKey) {
     const provider = new InfuraProvider(network, apiKey);
     const connection = provider.connection;
     if (connection.password) {
-      logger40.throwError("INFURA WebSocket project secrets unsupported", Logger.errors.UNSUPPORTED_OPERATION, {
+      logger39.throwError("INFURA WebSocket project secrets unsupported", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "InfuraProvider.getWebSocketProvider()"
       });
     }
@@ -28453,8 +30051,8 @@ var InfuraProvider = class extends UrlJsonRpcProvider {
     if (typeof apiKey === "string") {
       apiKeyObj.projectId = apiKey;
     } else if (apiKey.projectSecret != null) {
-      logger40.assertArgument(typeof apiKey.projectId === "string", "projectSecret requires a projectId", "projectId", apiKey.projectId);
-      logger40.assertArgument(typeof apiKey.projectSecret === "string", "invalid projectSecret", "projectSecret", "[REDACTED]");
+      logger39.assertArgument(typeof apiKey.projectId === "string", "projectSecret requires a projectId", "projectId", apiKey.projectId);
+      logger39.assertArgument(typeof apiKey.projectSecret === "string", "invalid projectSecret", "projectSecret", "[REDACTED]");
       apiKeyObj.projectId = apiKey.projectId;
       apiKeyObj.projectSecret = apiKey.projectSecret;
     } else if (apiKey.projectId) {
@@ -28500,7 +30098,7 @@ var InfuraProvider = class extends UrlJsonRpcProvider {
         host = "arbitrum-sepolia.infura.io";
         break;
       default:
-        logger40.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
+        logger39.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
           argument: "network",
           value: network
         });
@@ -28526,7 +30124,7 @@ var InfuraProvider = class extends UrlJsonRpcProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/json-rpc-batch-provider.js
+// node_modules/@ethersproject/providers/lib.esm/json-rpc-batch-provider.js
 var JsonRpcBatchProvider = class extends JsonRpcProvider {
   send(method, params) {
     const request = {
@@ -28590,18 +30188,18 @@ var JsonRpcBatchProvider = class extends JsonRpcProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/nodesmith-provider.js
-var logger41 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/nodesmith-provider.js
+var logger40 = new Logger(version23);
 var defaultApiKey3 = "ETHERS_JS_SHARED";
 var NodesmithProvider = class extends UrlJsonRpcProvider {
   static getApiKey(apiKey) {
     if (apiKey && typeof apiKey !== "string") {
-      logger41.throwArgumentError("invalid apiKey", "apiKey", apiKey);
+      logger40.throwArgumentError("invalid apiKey", "apiKey", apiKey);
     }
     return apiKey || defaultApiKey3;
   }
   static getUrl(network, apiKey) {
-    logger41.warn("NodeSmith will be discontinued on 2019-12-20; please migrate to another platform.");
+    logger40.warn("NodeSmith will be discontinued on 2019-12-20; please migrate to another platform.");
     let host = null;
     switch (network.name) {
       case "homestead":
@@ -28620,14 +30218,14 @@ var NodesmithProvider = class extends UrlJsonRpcProvider {
         host = "https://ethereum.api.nodesmith.io/v1/kovan/jsonrpc";
         break;
       default:
-        logger41.throwArgumentError("unsupported network", "network", arguments[0]);
+        logger40.throwArgumentError("unsupported network", "network", arguments[0]);
     }
     return host + "?apiKey=" + apiKey;
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/pocket-provider.js
-var logger42 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/pocket-provider.js
+var logger41 = new Logger(version23);
 var defaultApplicationId = "62e1ad51b37b8e00394bda3b";
 var PocketProvider = class extends UrlJsonRpcProvider {
   static getApiKey(apiKey) {
@@ -28646,7 +30244,7 @@ var PocketProvider = class extends UrlJsonRpcProvider {
     } else if (apiKey.applicationId) {
       apiKeyObj.applicationId = apiKey.applicationId;
     } else {
-      logger42.throwArgumentError("unsupported PocketProvider apiKey", "apiKey", apiKey);
+      logger41.throwArgumentError("unsupported PocketProvider apiKey", "apiKey", apiKey);
     }
     return apiKeyObj;
   }
@@ -28675,7 +30273,7 @@ var PocketProvider = class extends UrlJsonRpcProvider {
         host = "eth-ropsten.gateway.pokt.network";
         break;
       default:
-        logger42.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
+        logger41.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
           argument: "network",
           value: network
         });
@@ -28693,13 +30291,13 @@ var PocketProvider = class extends UrlJsonRpcProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/quicknode-provider.js
-var logger43 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/quicknode-provider.js
+var logger42 = new Logger(version23);
 var defaultApiKey4 = "919b412a057b5e9c9b6dce193c5a60242d6efadb";
 var QuickNodeProvider = class extends UrlJsonRpcProvider {
   static getApiKey(apiKey) {
     if (apiKey && typeof apiKey !== "string") {
-      logger43.throwArgumentError("invalid apiKey", "apiKey", apiKey);
+      logger42.throwArgumentError("invalid apiKey", "apiKey", apiKey);
     }
     return apiKey || defaultApiKey4;
   }
@@ -28761,14 +30359,14 @@ var QuickNodeProvider = class extends UrlJsonRpcProvider {
         host = "ethers.xdai.quiknode.pro";
         break;
       default:
-        logger43.throwArgumentError("unsupported network", "network", arguments[0]);
+        logger42.throwArgumentError("unsupported network", "network", arguments[0]);
     }
     return "https://" + host + "/" + apiKey;
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/web3-provider.js
-var logger44 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/web3-provider.js
+var logger43 = new Logger(version23);
 var _nextId = 1;
 function buildWeb3LegacyFetcher(provider, sendFunc) {
   const fetcher = "Web3LegacyFetcher";
@@ -28851,7 +30449,7 @@ function buildEip1193Fetcher(provider) {
 var Web3Provider = class extends JsonRpcProvider {
   constructor(provider, network) {
     if (provider == null) {
-      logger44.throwArgumentError("missing provider", "provider", provider);
+      logger43.throwArgumentError("missing provider", "provider", provider);
     }
     let path2 = null;
     let jsonRpcFetchFunc = null;
@@ -28875,7 +30473,7 @@ var Web3Provider = class extends JsonRpcProvider {
       } else if (provider.send) {
         jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.send.bind(provider));
       } else {
-        logger44.throwArgumentError("unsupported provider", "provider", provider);
+        logger43.throwArgumentError("unsupported provider", "provider", provider);
       }
       if (!path2) {
         path2 = "unknown:";
@@ -28890,8 +30488,8 @@ var Web3Provider = class extends JsonRpcProvider {
   }
 };
 
-// node_modules/ethers/node_modules/@ethersproject/providers/lib.esm/index.js
-var logger45 = new Logger(version24);
+// node_modules/@ethersproject/providers/lib.esm/index.js
+var logger44 = new Logger(version23);
 function getDefaultProvider(network, options) {
   if (network == null) {
     network = "homestead";
@@ -28907,13 +30505,13 @@ function getDefaultProvider(network, options) {
         case "wss":
           return new WebSocketProvider(network);
         default:
-          logger45.throwArgumentError("unsupported URL scheme", "network", network);
+          logger44.throwArgumentError("unsupported URL scheme", "network", network);
       }
     }
   }
   const n = getNetwork(network);
   if (!n || !n._defaultProvider) {
-    logger45.throwError("unsupported getDefaultProvider network", Logger.errors.NETWORK_ERROR, {
+    logger44.throwError("unsupported getDefaultProvider network", Logger.errors.NETWORK_ERROR, {
       operation: "getDefaultProvider",
       network
     });
@@ -29039,14 +30637,14 @@ __export(utils_exports, {
 });
 
 // node_modules/@ethersproject/solidity/lib.esm/_version.js
-var version25 = "solidity/5.8.0";
+var version24 = "solidity/5.8.0";
 
 // node_modules/@ethersproject/solidity/lib.esm/index.js
 var regexBytes = new RegExp("^bytes([0-9]+)$");
 var regexNumber = new RegExp("^(u?int)([0-9]*)$");
 var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
 var Zeros2 = "0000000000000000000000000000000000000000000000000000000000000000";
-var logger46 = new Logger(version25);
+var logger45 = new Logger(version24);
 function _pack(type, value, isArray) {
   switch (type) {
     case "address":
@@ -29069,7 +30667,7 @@ function _pack(type, value, isArray) {
   if (match2) {
     let size = parseInt(match2[2] || "256");
     if (match2[2] && String(size) !== match2[2] || size % 8 !== 0 || size === 0 || size > 256) {
-      logger46.throwArgumentError("invalid number type", "type", type);
+      logger45.throwArgumentError("invalid number type", "type", type);
     }
     if (isArray) {
       size = 256;
@@ -29081,10 +30679,10 @@ function _pack(type, value, isArray) {
   if (match2) {
     const size = parseInt(match2[1]);
     if (String(size) !== match2[1] || size === 0 || size > 32) {
-      logger46.throwArgumentError("invalid bytes type", "type", type);
+      logger45.throwArgumentError("invalid bytes type", "type", type);
     }
     if (arrayify(value).byteLength !== size) {
-      logger46.throwArgumentError(`invalid value for ${type}`, "value", value);
+      logger45.throwArgumentError(`invalid value for ${type}`, "value", value);
     }
     if (isArray) {
       return arrayify((value + Zeros2).substring(0, 66));
@@ -29096,7 +30694,7 @@ function _pack(type, value, isArray) {
     const baseType = match2[1];
     const count = parseInt(match2[2] || String(value.length));
     if (count != value.length) {
-      logger46.throwArgumentError(`invalid array length for ${type}`, "value", value);
+      logger45.throwArgumentError(`invalid array length for ${type}`, "value", value);
     }
     const result = [];
     value.forEach(function(value2) {
@@ -29104,11 +30702,11 @@ function _pack(type, value, isArray) {
     });
     return concat(result);
   }
-  return logger46.throwArgumentError("invalid type", "type", type);
+  return logger45.throwArgumentError("invalid type", "type", type);
 }
 function pack2(types, values) {
   if (types.length != values.length) {
-    logger46.throwArgumentError("wrong number of values; expected ${ types.length }", "values", values);
+    logger45.throwArgumentError("wrong number of values; expected ${ types.length }", "values", values);
   }
   const tight = [];
   types.forEach(function(type, index) {
@@ -29124,10 +30722,10 @@ function sha2562(types, values) {
 }
 
 // node_modules/@ethersproject/units/lib.esm/_version.js
-var version26 = "units/5.8.0";
+var version25 = "units/5.8.0";
 
 // node_modules/@ethersproject/units/lib.esm/index.js
-var logger47 = new Logger(version26);
+var logger46 = new Logger(version25);
 var names = [
   "wei",
   "kwei",
@@ -29140,7 +30738,7 @@ var names = [
 function commify(value) {
   const comps = String(value).split(".");
   if (comps.length > 2 || !comps[0].match(/^-?[0-9]*$/) || comps[1] && !comps[1].match(/^[0-9]*$/) || value === "." || value === "-.") {
-    logger47.throwArgumentError("invalid value", "value", value);
+    logger46.throwArgumentError("invalid value", "value", value);
   }
   let whole = comps[0];
   let negative = "";
@@ -29185,7 +30783,7 @@ function formatUnits(value, unitName) {
 }
 function parseUnits(value, unitName) {
   if (typeof value !== "string") {
-    logger47.throwArgumentError("value must be a string", "value", value);
+    logger46.throwArgumentError("value must be a string", "value", value);
   }
   if (typeof unitName === "string") {
     const index = names.indexOf(unitName);
@@ -29203,10 +30801,10 @@ function parseEther(ether) {
 }
 
 // node_modules/ethers/lib.esm/_version.js
-var version27 = "ethers/5.8.0";
+var version26 = "ethers/5.8.0";
 
 // node_modules/ethers/lib.esm/ethers.js
-var logger48 = new Logger(version27);
+var logger47 = new Logger(version26);
 
 // node_modules/ethers/lib.esm/index.js
 try {
@@ -31187,6 +32785,7 @@ function createPKPManager(config) {
 }
 
 // src/modules/loan/loan-creator.module.ts
+var import_dh_lit_actions = __toESM(require_pkg_src());
 var LoanCreator = class {
   config;
   transactionTimeoutMs;
@@ -31283,10 +32882,9 @@ var LoanCreator = class {
     } else if (this.config.litOps.config && pkpValidationRegistryAddress && pkpValidationRegistryAddress !== "0x0000000000000000000000000000000000000000") {
       this.config.litOps.config.pkpValidationRegistryAddress = pkpValidationRegistryAddress;
     }
-    const { DH_LIT_ACTIONS_CHIPOTLE: DH_LIT_ACTIONS_CHIPOTLE2 } = await import("@gvnrdao/dh-lit-actions");
     let certificationCid;
     if (isChipotleNetwork) {
-      if (!DH_LIT_ACTIONS_CHIPOTLE2.btcTransactionSigner?.authorizedCidHex) {
+      if (!import_dh_lit_actions.DH_LIT_ACTIONS_CHIPOTLE.btcTransactionSigner?.authorizedCidHex) {
         return failure(
           new SDKError({
             message: "DH_LIT_ACTIONS_CHIPOTLE.btcTransactionSigner.authorizedCidHex is required for loan creation (must match PKPValidation.getCid on-chain).",
@@ -31295,7 +32893,7 @@ var LoanCreator = class {
           })
         );
       }
-      certificationCid = DH_LIT_ACTIONS_CHIPOTLE2.btcTransactionSigner.authorizedCidHex.toLowerCase();
+      certificationCid = import_dh_lit_actions.DH_LIT_ACTIONS_CHIPOTLE.btcTransactionSigner.authorizedCidHex.toLowerCase();
     } else {
       throw new SDKError({
         message: `Unsupported litNetwork '${litNetwork}' for loan creation. Only the chipotle network is supported.`,
@@ -34891,8 +36489,8 @@ function createMockTokenManager(config) {
 }
 
 // src/modules/diamond-hands-sdk.ts
+var import_dh_lit_actions2 = __toESM(require_pkg_src());
 import { LitOps } from "@gvnrdao/dh-lit-ops";
-import { DH_LIT_ACTIONS_CHIPOTLE } from "@gvnrdao/dh-lit-actions";
 
 // src/utils/telegram-messaging.utils.ts
 var TelegramBot = null;
@@ -35221,7 +36819,6 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
       network: config.litNetwork || DEFAULT_LIT_NETWORK,
       signer: config.mode === "standalone" ? config.litOpsSigner : void 0,
       serviceEndpoint: isServiceModeConfig(config) ? config.serviceEndpoint : void 0,
-      serviceAuthToken: isServiceModeConfig(config) ? config.serviceAuthToken : void 0,
       debug: config.debug,
       litNodeConnectTimeoutMs: config.litNodeConnectTimeoutMs
       // TODO Round 2: Add litActionExecution config when added to config.i.ts interface
@@ -36000,7 +37597,7 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
           }
         } else {
           try {
-            const nagaPkpNftAddress = DH_LIT_ACTIONS_CHIPOTLE.pkpValidator?.pkp?.ethAddress ?? "";
+            const nagaPkpNftAddress = import_dh_lit_actions2.DH_LIT_ACTIONS_CHIPOTLE.pkpValidator?.pkp?.ethAddress ?? "";
             pkpPublicKey = await getPKPPublicKeyFromTokenId(
               position2.pkpId,
               this.getProviderOrThrow(),
@@ -37103,7 +38700,7 @@ Error data: ${errorData || "none"}`
               wasLiquidated: false
             };
           }
-          const nagaPkpNftAddressLiq = DH_LIT_ACTIONS_CHIPOTLE.pkpValidator?.pkp?.ethAddress ?? "";
+          const nagaPkpNftAddressLiq = import_dh_lit_actions2.DH_LIT_ACTIONS_CHIPOTLE.pkpValidator?.pkp?.ethAddress ?? "";
           const pkpPublicKey = await getPKPPublicKeyFromTokenId(
             position.pkpId,
             this.getProviderOrThrow(),
@@ -39184,7 +40781,7 @@ Error data: ${errorData || "none"}`
           }
         } else {
           try {
-            const nagaPkpNftAddress = DH_LIT_ACTIONS_CHIPOTLE.pkpValidator?.pkp?.ethAddress ?? "";
+            const nagaPkpNftAddress = import_dh_lit_actions2.DH_LIT_ACTIONS_CHIPOTLE.pkpValidator?.pkp?.ethAddress ?? "";
             pkpPublicKey = await getPKPPublicKeyFromTokenId(
               position.pkpId,
               this.getProviderOrThrow(),
@@ -39815,7 +41412,7 @@ Error data: ${errorData || "none"}`
       } else {
         try {
           const pkpId = position.pkpId;
-          const nagaPkpNftAddress = DH_LIT_ACTIONS_CHIPOTLE.pkpValidator?.pkp?.ethAddress ?? "";
+          const nagaPkpNftAddress = import_dh_lit_actions2.DH_LIT_ACTIONS_CHIPOTLE.pkpValidator?.pkp?.ethAddress ?? "";
           pkpPublicKey = await getPKPPublicKeyFromTokenId(
             pkpId,
             this.getProviderOrThrow(),