@seedprotocol/publish 0.4.18 → 0.4.20

package/dist/index-P7oBN4Yu.js

@@ -0,0 +1,4785 @@
+import { getGetAdditionalSyncAddresses as yn, getAttesterForSeed as gn, getVersionsForSeedUid as wn, getMetadataAttestationUidsForSeedUid as bn, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as An, updateSeedRevokedAt as vn, setGetPublisherForNewSeeds as Sn, setRevokeExecutor as En, setAdditionalSyncAddresses as In, DEFAULT_ARWEAVE_GRAPHQL_URL as Pn, client as pt, getSegmentedItemProperties as at, setSchemaUidForModel as He, setSchemaUidForSchemaDefinition as oe, INTERNAL_DATA_TYPES as Un, getEasSchemaForItemProperty as Tn, getRelatedItemsForPublish as Dn, BaseArweaveClient as xn, Item as ae, getCorrectId as Mt, BaseFileManager as G, getUploadPipelineTransactionStatus as Cn, BaseDb as B, arweaveL1FinalizeJobs as De, resolvePublishPayloadValues as mt, getItemPropertiesFromEas as Rn, updateVersionUid as _n, itemHasPublishUploadCandidates as Ln, isItemOwned as Ot, validateItemForPublish as Mn, publishProcesses as P, uploadProcesses as On } from "@seedprotocol/sdk";
+import { prepareContractCall as x, readContract as _, createThirdwebClient as Bn, getContract as V, sendTransaction as N, waitForReceipt as k, parseEventLogs as st, prepareEvent as Y } from "thirdweb";
+import { createWallet as Ce, inAppWallet as Bt } from "thirdweb/wallets";
+import { useActiveAccount as Fn, ThirdwebProvider as Nn, ConnectButton as kn, darkTheme as Hn } from "thirdweb/react";
+import { isContractDeployed as $n } from "thirdweb/utils";
+import { useState as Ae, useRef as Ft, useEffect as te, createContext as Vn, useContext as Wn, useMemo as Nt } from "react";
+import { optimismSepolia as v } from "thirdweb/chains";
+import K from "debug";
+import { encodeAbiParameters as kt, decodeAbiParameters as qn } from "viem";
+import { jsx as me, jsxs as jn } from "react/jsx-runtime";
+import { SeedProvider as Gn, useLiveQuery as ve } from "@seedprotocol/react";
+import { getInstalledModules as Yn, installModule as Jn } from "thirdweb/modules";
+import { SchemaEncoder as zn, ZERO_BYTES32 as Zn, NO_EXPIRATION as Kn, SchemaRegistry as $e, ZERO_ADDRESS as Qe } from "@ethereum-attestation-service/eas-sdk";
+import { fromPromise as he, fromCallback as ye, setup as Ht, assign as T, enqueueActions as Le, createActor as Xe } from "xstate";
+import Qn from "arweave";
+import { ethers as H } from "ethers";
+import { readFile as Xn } from "node:fs/promises";
+import { and as ea, eq as Z, desc as fe, notInArray as ta, inArray as na } from "drizzle-orm";
+import { useSelector as aa } from "@xstate/react";
+async function sa(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x8878ed33",
+      [
+        {
+          type: "address",
+          name: "_adminSigner"
+        },
+        {
+          type: "bytes",
+          name: "_data"
+        }
+      ],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: [e.adminSigner, e.data]
+  });
+}
+function ra(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xd8fd8f44",
+      [
+        {
+          type: "address",
+          name: "_admin"
+        },
+        {
+          type: "bytes",
+          name: "_data"
+        }
+      ],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: [e.admin, e.data]
+  });
+}
+const $t = "0x4200000000000000000000000000000000000020", oa = "0x44d562ac1d7cd77e232978687fea027ace48f719cf1d58c7888e509663bb87fc", Vt = "0x76f47d88bfaf670f5208911181fcdc0e160cb16d", Wt = "0x4200000000000000000000000000000000000021", ft = "0xcd8c945872df8e664e55cf8885c85ea3ea8f2148", L = {
+  SUCCESS: "success",
+  FAILURE: "failure"
+}, ia = [
+  "pollingForConfirmation",
+  "uploadingData",
+  "uploadingViaBundler"
+], ca = 3e4, da = K("permaPress:helpers:thirdweb");
+let Ve = null;
+function R() {
+  if (!Ve) {
+    const { thirdwebClientId: e } = C();
+    Ve = Bn({ clientId: e });
+  }
+  return Ve;
+}
+const xr = [
+  // embeddedWallet(),
+  Ce("io.metamask")
+  // createWallet("com.coinbase.wallet"),
+  // createWallet("me.rainbow"),
+], Cr = () => {
+  const [e, t] = Ae(null);
+  return Ce("io.metamask"), Ft(!1), te(() => {
+    (async () => {
+    })();
+  }, []), e;
+}, Rr = () => {
+  const e = Fn(), [t, n] = Ae(null);
+  return te(() => {
+    !e || !e.address || n(V({
+      client: R(),
+      chain: v,
+      address: e.address
+    }));
+  }, [e]), t;
+}, qt = () => {
+  const { thirdwebAccountFactoryAddress: e } = C();
+  return V({
+    client: R(),
+    chain: v,
+    address: e
+  });
+};
+async function jt(e, t = "0x") {
+  const n = qt();
+  return sa({
+    contract: n,
+    adminSigner: e,
+    data: t
+  });
+}
+async function Re(e) {
+  const t = V({
+    client: R(),
+    chain: v,
+    address: e
+  });
+  return $n(t);
+}
+async function ht(e) {
+  if (!e)
+    return { needsDeploy: !0 };
+  if (await Re(e.address))
+    return { address: e.address, account: e };
+  const n = await jt(e.address);
+  return await Re(n) ? { address: n, account: e } : { needsDeploy: !0 };
+}
+const _r = [
+  Ce("io.metamask"),
+  Ce("me.rainbow")
+], la = async (e) => {
+  const t = qt(), n = ra({
+    contract: t,
+    admin: e.address,
+    data: "0x"
+  }), a = await N({
+    account: e,
+    transaction: n
+  });
+  da("createAccountTx result:", a);
+  const s = await k({
+    client: R(),
+    transactionHash: a.transactionHash,
+    chain: v
+  });
+  if (!s)
+    throw new Error("Failed to deploy smart wallet");
+  return s;
+}, Lr = {
+  name: "Seed Protocol",
+  description: "Seed Protocol",
+  url: "https://seedprotocol.io"
+};
+async function rt(e = v) {
+  const t = Me();
+  await t.autoConnect({ client: R(), chain: e });
+  const n = t.getAccount();
+  if (!n)
+    throw new Error("Failed to get managed account");
+  return n.address;
+}
+async function ua() {
+  try {
+    const e = ot();
+    return await e.autoConnect({ client: R(), chain: v }), e.getAccount() ?? null;
+  } catch {
+    return null;
+  }
+}
+const Me = () => Bt({
+  auth: {
+    options: [
+      "farcaster",
+      "email",
+      "passkey",
+      "phone"
+    ]
+  },
+  executionMode: {
+    mode: "EIP4337",
+    smartAccount: {
+      chain: v,
+      factoryAddress: Vt,
+      gasless: !0
+    }
+  }
+  // executionMode: {
+  //   mode: 'EIP4337',
+  //   smartAccount: {
+  //     chain: optimismSepolia,
+  //     factoryAddress: thirdwebAccountFactoryAddress,
+  //     gasless: true,
+  //     overrides: {
+  //       // Custom paymaster that passes through but lets you modify the UserOp
+  //       paymaster: async (userOp) => {
+  //         const hexifyBigInts: any = (obj: any) => {
+  //           if (typeof obj === "bigint") return `0x${obj.toString(16)}`;
+  //           if (Array.isArray(obj)) return obj.map(hexifyBigInts);
+  //           if (obj && typeof obj === "object") {
+  //             return Object.fromEntries(
+  //               Object.entries(obj).map(([k, v]) => [k, hexifyBigInts(v)])
+  //             );
+  //           }
+  //           return obj;
+  //         };
+  //         const chainIdHex = `0x${optimismSepolia.id.toString(16)}`;
+  //         // Increase callGasLimit before sending to paymaster
+  //         const modifiedUserOp = hexifyBigInts({
+  //           ...userOp,
+  //           callGasLimit: BigInt(8000000), // Double it, or set a fixed value
+  //         });
+  //         console.log("[SmartWallet Paymaster]", getPublishConfig().thirdwebClientId);
+  //         // Call thirdweb's default paymaster endpoint
+  //         const response = await fetch(
+  //           `https://${optimismSepolia.id}.bundler.thirdweb.com/v2`,
+  //           {
+  //             method: "POST",
+  //             headers: { 
+  //               "Content-Type": "application/json",
+  //               "X-Client-Id": getPublishConfig().thirdwebClientId,
+  //             },
+  //             body: JSON.stringify({
+  //               id: 1,
+  //               jsonrpc: "2.0",
+  //               method: "pm_sponsorUserOperation",
+  //               params: [modifiedUserOp, '0x5ff137d4b0fdcd49dca30c7cf57e578a026d2789', chainIdHex],
+  //             }),
+  //           }
+  //         );
+  //         const data = await response.json();
+  //         console.log("[SmartWallet Paymaster Response]", data);
+  //         return {
+  //           paymasterAndData: data.result.paymasterAndData,
+  //           preVerificationGas: data.result.preVerificationGas,
+  //           verificationGasLimit: data.result.verificationGasLimit,
+  //           callGasLimit: data.result.callGasLimit,
+  //         };
+  //       },
+  //       execute: (accountContract, transaction) => {
+  //         // Log the gas that was set on the transaction
+  //         console.log("[SmartWallet Execute]", {
+  //           gas: transaction.gas,
+  //           to: transaction.to,
+  //           dataLength: transaction.data?.length,
+  //         });
+  //         // Return the default execute call — don't change behavior,
+  //         // just observe what's being passed through
+  //         return prepareContractCall({
+  //           contract: accountContract,
+  //           method: "function execute(address, uint256, bytes)",
+  //           params: [
+  //             transaction.to ?? "",
+  //             transaction.value ?? 0n,
+  //             transaction.data ?? "0x",
+  //           ],
+  //           gas: transaction.gas, // Pass through whatever was set
+  //         });
+  //       },
+  //     },
+  //   }
+  // }
+}), ot = () => Bt({
+  auth: {
+    options: [
+      "farcaster",
+      "email",
+      "passkey",
+      "phone"
+    ]
+  },
+  executionMode: {
+    mode: "EIP7702",
+    sponsorGas: !0
+  }
+}), pa = () => [
+  ot()
+], ma = [
+  { type: "error", name: "AccessDenied", inputs: [] },
+  { type: "error", name: "AlreadyRevoked", inputs: [] },
+  { type: "error", name: "InvalidRevocation", inputs: [] },
+  { type: "error", name: "InvalidRevocations", inputs: [] },
+  { type: "error", name: "InvalidSchema", inputs: [] },
+  { type: "error", name: "Irrevocable", inputs: [] },
+  { type: "error", name: "NotFound", inputs: [] },
+  { type: "error", name: "NotPayable", inputs: [] },
+  { type: "error", name: "InsufficientValue", inputs: [] },
+  { type: "error", name: "InvalidLength", inputs: [] }
+], fa = () => Y({
+  signature: "event Attested(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schemaUID)"
+}), ha = "0x0000000000000000000000000000000000000000", q = "0x" + "0".repeat(64);
+function yt(e, t, n) {
+  const { easContractAddress: a } = C(), s = V({
+    client: e,
+    chain: t,
+    address: a
+  });
+  return x({
+    contract: s,
+    method: "function attest((bytes32 schema,(address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value) data) request) payable returns (bytes32)",
+    params: [
+      {
+        schema: n.schema,
+        data: {
+          recipient: n.data.recipient ?? ha,
+          expirationTime: n.data.expirationTime ?? 0n,
+          revocable: n.data.revocable ?? !0,
+          refUID: n.data.refUID,
+          data: n.data.data,
+          value: n.data.value ?? 0n
+        }
+      }
+    ]
+  });
+}
+function ya(e, t, n) {
+  const { easContractAddress: a } = C(), s = V({
+    client: e,
+    chain: t,
+    address: a
+  });
+  return x({
+    contract: s,
+    method: "function multiAttest((bytes32 schema,(address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value)[] data)[] requests) payable returns (bytes32[])",
+    params: [n]
+  });
+}
+function We(e) {
+  return kt([{ type: "bytes32" }], [e]);
+}
+function gt(e, t) {
+  if (!e.logs?.length) return;
+  const n = t.toLowerCase(), a = e.logs.filter((s) => s.address && s.address.toLowerCase() === n);
+  if (a.length)
+    try {
+      const o = st({
+        logs: a,
+        events: [fa()],
+        strict: !1
+      })[0]?.args?.uid;
+      if (o && o !== q) return o;
+    } catch {
+    }
+}
+function ga(e, t, n) {
+  const { easContractAddress: a } = C(), s = V({
+    client: e,
+    chain: t,
+    address: a,
+    abi: [...ma]
+  });
+  return x({
+    contract: s,
+    method: "function multiRevoke((bytes32 schema,(bytes32 uid,uint256 value)[] data)[] multiRequests) payable",
+    params: [
+      n.map((r) => ({
+        schema: r.schema,
+        data: r.data.map((o) => ({
+          uid: o.uid,
+          value: o.value ?? 0n
+        }))
+      }))
+    ]
+  });
+}
+async function wa(e) {
+  const { account: t, attester: n } = e;
+  if (!n || t.address.toLowerCase() === n.toLowerCase())
+    return t;
+  const a = yn();
+  if (a) {
+    const s = await a(), r = n.toLowerCase();
+    if (s?.some((o) => o?.toLowerCase() === r))
+      throw new Error(
+        "Revocation not supported for items published via the modular executor."
+      );
+  }
+  try {
+    const s = await jt(t.address), r = n.toLowerCase(), o = s.toLowerCase();
+    if (r === o && await Re(s)) {
+      const c = Me();
+      await c.autoConnect({
+        client: R(),
+        chain: v
+      });
+      const u = c.getAccount();
+      if (u)
+        return u;
+    }
+  } catch {
+  }
+  return t;
+}
+async function ba(e) {
+  const { seedLocalId: t, seedUid: n, seedSchemaUid: a } = e, s = await ua();
+  if (!s)
+    throw new Error("No wallet connected. Connect a wallet to revoke attestations.");
+  const r = await gn({ seedLocalId: t, seedUid: n }), o = await wa({ account: s, attester: r }), i = R(), [c, u] = await Promise.all([
+    wn(n),
+    bn(n)
+  ]), d = c.map((h) => h.uid), p = /* @__PURE__ */ new Map();
+  for (const { uid: h, schemaUid: y } of u) {
+    const f = p.get(y) ?? [];
+    f.push(h), p.set(y, f);
+  }
+  const l = [];
+  for (const [h, y] of p)
+    y.length > 0 && l.push({
+      schema: h,
+      data: y.map((f) => ({ uid: f }))
+    });
+  d.length > 0 && l.push({
+    schema: An,
+    data: d.map((h) => ({ uid: h }))
+  }), l.push({
+    schema: a,
+    data: [{ uid: n }]
+  });
+  for (const h of l) {
+    if (h.data.length === 0) continue;
+    const y = ga(i, v, [h]);
+    try {
+      const f = await N({ account: o, transaction: y });
+      await k({
+        client: i,
+        chain: v,
+        transactionHash: f.transactionHash
+      });
+    } catch (f) {
+      const A = f instanceof Error ? f.message : String(f);
+      if (A.includes("AccessDenied") || A.includes("0x4ca88867"))
+        throw new Error(
+          "Only the original attester can revoke attestations. Connect the wallet that published this item."
+        );
+      if (A.includes("AlreadyRevoked"))
+        continue;
+      throw f;
+    }
+  }
+  const m = Math.floor(Date.now() / 1e3);
+  await vn({ seedLocalId: t, revokedAt: m });
+}
+let it = null;
+function Aa(e) {
+  it = e;
+}
+function va() {
+  return it;
+}
+function Gt(e) {
+  Aa(e), Sn(async () => {
+    try {
+      return await rt(v);
+    } catch {
+      return;
+    }
+  }), En(ba), import("./worker-BxY09Tmw.js").then((t) => {
+    t.startArweaveL1FinalizeWorker();
+  }), In(async () => e.useModularExecutor && e.modularAccountModuleContract ? [e.modularAccountModuleContract] : []);
+}
+const Mr = Gt;
+function C() {
+  const e = it;
+  if (!e)
+    throw new Error(
+      "@seedprotocol/publish: Call initPublish() or ensure PublishProvider is mounted with config before using the publish package"
+    );
+  const t = e.useArweaveBundler ?? !1, n = e.arweaveUploadVerificationBaseUrl ?? e.uploadApiBaseUrl, a = e.arweaveGraphqlUrl ?? Pn;
+  return {
+    ...e,
+    thirdwebAccountFactoryAddress: Vt,
+    easContractAddress: Wt,
+    useIntegerLocalIds: e.useIntegerLocalIds ?? !1,
+    useDirectEas: e.useDirectEas ?? !1,
+    modularAccountModuleData: e.modularAccountModuleData ?? "0x",
+    useModularExecutor: e.useModularExecutor ?? !1,
+    useArweaveBundler: t,
+    arweaveUploadVerificationBaseUrl: n,
+    arweaveGraphqlUrl: a,
+    autoDeployManagedAccount: e.autoDeployManagedAccount ?? !1
+  };
+}
+class Yt extends Error {
+  constructor(t, n, a, s, r = "METADATA_PROPERTIES_MISSING") {
+    super(t), this.seedLocalId = n, this.expectedSchemas = a, this.foundSchemas = s, this.code = r, this.name = "AttestationVerificationError";
+  }
+}
+class Q extends Error {
+  constructor(t, n, a, s) {
+    super(t), this.code = n, this.managedAddress = a, this.name = "ManagedAccountPublishError", this.underlyingCause = s;
+  }
+  /** Original error when connection or deployment failed (avoids shadowing `Error.cause`). */
+  underlyingCause;
+}
+function wt(e) {
+  if (e instanceof Q) return !0;
+  if (typeof e != "object" || e === null) return !1;
+  const t = e;
+  return t.name === "ManagedAccountPublishError" && typeof t.code == "string";
+}
+function Sa(e, t = 700) {
+  if (e == null) return "";
+  if (e instanceof Error) {
+    const n = e.cause instanceof Error ? ` | cause: ${e.cause.message}` : "";
+    return (e.message + n).slice(0, t);
+  }
+  if (typeof e == "object") {
+    const n = e, a = [];
+    if (typeof n.message == "string" && a.push(n.message), typeof n.shortMessage == "string" && a.push(n.shortMessage), typeof n.details == "string" && a.push(n.details), typeof n.reason == "string" && a.push(n.reason), a.length) return a.join(" | ").slice(0, t);
+    try {
+      return JSON.stringify(e).slice(0, t);
+    } catch {
+      return String(e).slice(0, t);
+    }
+  }
+  return String(e).slice(0, t);
+}
+function Ea(e) {
+  return /Router:\s*function does not exist/i.test(Sa(e));
+}
+const Jt = Vn(null);
+function Ia() {
+  const e = Wn(Jt);
+  if (!e)
+    throw new Error("usePublishConfig must be used within PublishProvider");
+  return e;
+}
+const Or = ({
+  children: e,
+  config: t,
+  queryClient: n,
+  queryClientRef: a
+}) => (te(() => {
+  t && Gt(t);
+}, [t]), /* @__PURE__ */ me(Jt.Provider, { value: t ?? va(), children: /* @__PURE__ */ me(Nn, { children: /* @__PURE__ */ me(Gn, { queryClient: n, queryClientRef: a, children: e }) }) })), Pa = "The executor module could not be installed on your publishing account on Optimism Sepolia. Reconnect and try again, or contact support if this persists.";
+async function et(e, t, n) {
+  const { modularAccountModuleContract: a } = n;
+  if (!a) return;
+  const s = V({
+    client: R(),
+    chain: v,
+    address: e
+  });
+  try {
+    const r = await Yn({ contract: s }), o = a.toLowerCase();
+    if (r.some(
+      (d) => d.implementation?.toLowerCase() === o
+    )) return;
+    const c = Jn({
+      contract: s,
+      moduleContract: a,
+      data: kt([{ type: "address" }], [Wt])
+    }), u = await N({ transaction: c, account: t });
+    await k({
+      client: R(),
+      transactionHash: u.transactionHash,
+      chain: v
+    });
+  } catch (r) {
+    if (Ea(r))
+      return;
+    throw new Q(
+      Pa,
+      "EXECUTOR_MODULE_NOT_INSTALLED",
+      e,
+      r
+    );
+  }
+}
+function Se(e) {
+  console.error("[ConnectButton] Wallet setup / module install failed:", e), C().onWalletSetupWarning?.(e);
+}
+async function Ua(e, t, n) {
+  if (n.modularAccountModuleContract) {
+    if (n.useModularExecutor) {
+      if (!t) {
+        Se(
+          new Error(
+            "Executor module: managed account address not available yet (managed wallet may still be syncing)."
+          )
+        );
+        return;
+      }
+      try {
+        const a = Me();
+        await a.autoConnect({ client: R(), chain: v });
+        const s = a.getAccount();
+        if (!s) {
+          Se(new Error("Executor module: managed wallet has no account"));
+          return;
+        }
+        await et(t, s, n);
+      } catch (a) {
+        Se(a);
+      }
+      return;
+    }
+    try {
+      await et(e.address, e, n);
+    } catch (a) {
+      Se(a);
+    }
+  }
+}
+const Br = () => {
+  const e = Ia(), t = async () => {
+    console.log("[ConnectButton] Disconnected");
+    try {
+      await pt.setAddresses([]);
+    } catch (a) {
+      console.warn("[ConnectButton] Failed to clear seed client addresses:", a);
+    }
+  }, n = async (a, s) => {
+    const r = a.getAccount();
+    if (!r) return;
+    console.log("[ConnectButton] Connected", r.address);
+    const o = /* @__PURE__ */ new Set([r.address.toLowerCase()]);
+    let i;
+    if (e.useModularExecutor)
+      try {
+        i = await rt(v), o.add(i.toLowerCase());
+      } catch {
+      }
+    try {
+      await pt.setAddresses({ owned: [...o] });
+    } catch (c) {
+      console.warn("[ConnectButton] Failed to set seed client addresses:", c);
+    }
+    await Ua(r, i, e);
+  };
+  return /* @__PURE__ */ me(
+    kn,
+    {
+      client: R(),
+      wallets: pa(),
+      autoConnect: !0,
+      chain: v,
+      chains: [v],
+      onConnect: n,
+      onDisconnect: t,
+      theme: Hn({
+        colors: {
+          primaryButtonBg: "#1D2939",
+          primaryButtonText: "#FFFFFF",
+          secondaryButtonHoverBg: "#1D2939",
+          connectedButtonBg: "#101828",
+          connectedButtonBgHover: "#1D2939",
+          borderColor: "#344054"
+        }
+      })
+    }
+  );
+}, Fr = ({
+  value: e,
+  onChange: t,
+  disabled: n = !1,
+  "aria-label": a = "Publish mode"
+}) => {
+  const s = {
+    display: "inline-flex",
+    gap: 8,
+    flexWrap: "wrap"
+  }, r = (o) => ({
+    padding: "8px 14px",
+    fontSize: 13,
+    borderRadius: 8,
+    border: `1px solid ${o ? "#344054" : "#D0D5DD"}`,
+    background: o ? "#101828" : "#fff",
+    color: o ? "#fff" : "#344054",
+    cursor: n ? "not-allowed" : "pointer",
+    opacity: n ? 0.6 : 1
+  });
+  return /* @__PURE__ */ jn("div", { role: "group", "aria-label": a, style: s, children: [
+    /* @__PURE__ */ me(
+      "button",
+      {
+        type: "button",
+        disabled: n,
+        style: r(e === "patch"),
+        onClick: () => t("patch"),
+        children: "Publish updates"
+      }
+    ),
+    /* @__PURE__ */ me(
+      "button",
+      {
+        type: "button",
+        disabled: n,
+        style: r(e === "new_version"),
+        onClick: () => t("new_version"),
+        children: "New version"
+      }
+    )
+  ] });
+}, Ta = [
+  {
+    inputs: [{ internalType: "bytes32", name: "uid", type: "bytes32" }],
+    name: "getSchema",
+    outputs: [
+      {
+        components: [
+          { internalType: "bytes32", name: "uid", type: "bytes32" },
+          { internalType: "contract ISchemaResolver", name: "resolver", type: "address" },
+          { internalType: "bool", name: "revocable", type: "bool" },
+          { internalType: "string", name: "schema", type: "string" }
+        ],
+        internalType: "struct SchemaRecord",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "string", name: "schema", type: "string" },
+      { internalType: "contract ISchemaResolver", name: "resolver", type: "address" },
+      { internalType: "bool", name: "revocable", type: "bool" }
+    ],
+    name: "register",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+], Da = "0x" + "0".repeat(64);
+function xa(e, t) {
+  return V({
+    client: e,
+    chain: t,
+    address: $t,
+    abi: Ta
+  });
+}
+const Ca = "function getSchema(bytes32 uid) view returns ((bytes32 uid, address resolver, bool revocable, string schema))";
+async function Ee(e, t, n) {
+  const a = V({
+    client: e,
+    chain: t,
+    address: $t
+    // No ABI - use string method so thirdweb parses the exact signature and produces correct selector
+  }), s = await _({
+    contract: a,
+    method: Ca,
+    params: [n]
+  });
+  return !s || s.uid === Da ? null : s;
+}
+function qe(e, t, n) {
+  const a = xa(e, t);
+  return x({
+    contract: a,
+    method: "register",
+    params: [n.schema, n.resolverAddress, n.revocable]
+  });
+}
+const Ra = "0x0000000000000000000000000000000000000000";
+function je(e, t, n) {
+  const s = new zn("bytes32 schemaId,string name").encodeData([
+    { name: "schemaId", value: n.schemaUid, type: "bytes32" },
+    { name: "name", value: n.schemaName, type: "string" }
+  ]), { easContractAddress: r } = C(), o = V({
+    client: e,
+    chain: t,
+    address: r
+    // No ABI - use string method so thirdweb parses the exact signature
+  });
+  return x({
+    contract: o,
+    method: "function attest((bytes32 schema,(address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value) data) request) payable returns (bytes32)",
+    params: [
+      {
+        schema: oa,
+        data: {
+          recipient: Ra,
+          expirationTime: BigInt(Kn),
+          revocable: !0,
+          refUID: Zn,
+          data: s,
+          value: 0n
+        }
+      }
+    ]
+  });
+}
+const ie = "0x0000000000000000000000000000000000000000", ce = !0;
+function Ge(e) {
+  return e.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+async function _a(e) {
+  const { itemRelationProperties: t, itemImageProperties: n, itemListProperties: a } = await at(e), s = /* @__PURE__ */ new Set();
+  e.modelName && s.add(e.modelName);
+  for (const r of t) {
+    const o = r.propertyDef?.ref;
+    o && s.add(o);
+  }
+  for (const r of n) {
+    const o = r.propertyDef?.dataType;
+    o === "File" ? s.add("File") : o === "Html" ? s.add("Html") : s.add("Image");
+  }
+  for (const r of a) {
+    const o = r.propertyDef?.ref;
+    o && s.add(o);
+  }
+  return s;
+}
+async function Oe(e, t, n, a) {
+  const { itemBasicProperties: s, itemRelationProperties: r, itemImageProperties: o, itemListProperties: i } = await at(e), c = [
+    ...s,
+    ...r,
+    ...o,
+    ...i
+  ], u = /* @__PURE__ */ new Set(), d = await _a(e), p = /* @__PURE__ */ new Set();
+  for (const f of d) {
+    const A = `bytes32 ${Ge(f)}`, g = $e.getSchemaUID(
+      A,
+      ie,
+      ce
+    );
+    if (await Ee(n, a, g)) {
+      He({ modelName: f, schemaUid: g });
+      continue;
+    }
+    if (p.has(g)) {
+      He({ modelName: f, schemaUid: g });
+      continue;
+    }
+    try {
+      const S = qe(n, a, {
+        schema: A,
+        resolverAddress: ie,
+        revocable: ce
+      }), E = await N({
+        account: t,
+        transaction: S
+      });
+      await k({
+        client: n,
+        chain: a,
+        transactionHash: E.transactionHash
+      });
+    } catch (S) {
+      throw new Error(
+        `Failed to register EAS schema for model ${f}: ${S instanceof Error ? S.message : String(S)}`
+      );
+    }
+    try {
+      const S = je(n, a, {
+        schemaUid: g,
+        schemaName: Ge(f)
+      }), E = await N({
+        account: t,
+        transaction: S
+      });
+      await k({
+        client: n,
+        chain: a,
+        transactionHash: E.transactionHash
+      });
+    } catch (S) {
+      throw new Error(
+        `Failed to name EAS schema for model ${f}: ${S instanceof Error ? S.message : String(S)}`
+      );
+    }
+    p.add(g), He({ modelName: f, schemaUid: g });
+  }
+  const l = "string storage_transaction_id", m = $e.getSchemaUID(
+    l,
+    ie,
+    ce
+  );
+  if (await Ee(n, a, m))
+    oe({ text: l, schemaUid: m });
+  else if (!u.has(m) && (d.has("Image") || d.has("File") || d.has("Html"))) {
+    try {
+      const f = qe(n, a, {
+        schema: l,
+        resolverAddress: ie,
+        revocable: ce
+      }), A = await N({ account: t, transaction: f });
+      await k({ client: n, chain: a, transactionHash: A.transactionHash });
+      const g = je(n, a, {
+        schemaUid: m,
+        schemaName: "storage_transaction_id"
+      }), I = await N({ account: t, transaction: g });
+      await k({ client: n, chain: a, transactionHash: I.transactionHash });
+    } catch (f) {
+      throw new Error(
+        `Failed to register EAS schema for storageTransactionId: ${f instanceof Error ? f.message : String(f)}`
+      );
+    }
+    u.add(m), oe({ text: l, schemaUid: m });
+  }
+  for (const f of c) {
+    if (!f.propertyDef) continue;
+    const A = Un[f.propertyDef.dataType]?.eas ?? "string", g = f, I = g.storagePropertyName && g.storagePropertyName.length > 0 ? g.storagePropertyName : f.propertyName, S = Ge(I), E = `${A} ${S}`, D = [
+      "string",
+      "address",
+      "bool",
+      "bytes",
+      "bytes32",
+      "uint8",
+      "uint16",
+      "uint32",
+      "uint64",
+      "uint128",
+      "uint256"
+    ].includes(A) ? A : void 0;
+    let w = await Tn({
+      schemaUid: f.schemaUid,
+      propertyName: I,
+      easDataType: D
+    });
+    if (w) {
+      const b = await Ee(n, a, w.id);
+      if (b && b.schema === E) {
+        oe({ text: E, schemaUid: w.id });
+        continue;
+      }
+    }
+    const U = $e.getSchemaUID(E, ie, ce);
+    if (await Ee(n, a, U)) {
+      oe({ text: E, schemaUid: U });
+      continue;
+    }
+    if (u.has(U)) {
+      oe({ text: E, schemaUid: U });
+      continue;
+    }
+    try {
+      const b = qe(n, a, {
+        schema: E,
+        resolverAddress: ie,
+        revocable: ce
+      }), M = await N({
+        account: t,
+        transaction: b
+      });
+      await k({
+        client: n,
+        chain: a,
+        transactionHash: M.transactionHash
+      });
+    } catch (b) {
+      throw new Error(
+        `Failed to register EAS schema for property ${f.propertyName}: ${b instanceof Error ? b.message : String(b)}`
+      );
+    }
+    try {
+      const b = je(n, a, {
+        schemaUid: U,
+        schemaName: S
+      }), M = await N({
+        account: t,
+        transaction: b
+      });
+      await k({
+        client: n,
+        chain: a,
+        transactionHash: M.transactionHash
+      });
+    } catch (b) {
+      throw new Error(
+        `Failed to name EAS schema for property ${f.propertyName}: ${b instanceof Error ? b.message : String(b)}`
+      );
+    }
+    u.add(U), oe({ text: E, schemaUid: U });
+  }
+  const y = await Dn(e);
+  for (const f of y)
+    await Oe(f, t, n, a);
+}
+function Nr(e = {}) {
+  return Y({
+    signature: "event AdminUpdated(address indexed signer, bool isAdmin)",
+    filters: e
+  });
+}
+function kr() {
+  return Y({
+    signature: "event Initialized(uint8 version)"
+  });
+}
+function Hr(e = {}) {
+  return Y({
+    signature: "event SignerPermissionsUpdated(address indexed authorizingSigner, address indexed targetSigner, (address signer, uint8 isAdmin, address[] approvedTargets, uint256 nativeTokenLimitPerTransaction, uint128 permissionStartTimestamp, uint128 permissionEndTimestamp, uint128 reqValidityStartTimestamp, uint128 reqValidityEndTimestamp, bytes32 uid) permissions)",
+    filters: e
+  });
+}
+function $r() {
+  return Y({
+    signature: "event ContractURIUpdated(string prevURI, string newURI)"
+  });
+}
+function La() {
+  return Y({
+    signature: "event CreatedAttestation((bytes32 schemaUid, bytes32 attestationUid) result)"
+  });
+}
+function Vr() {
+  return Y({
+    signature: "event EIP712DomainChanged()"
+  });
+}
+function Wr() {
+  return Y({
+    signature: "event Log(string message)"
+  });
+}
+function qr(e = {}) {
+  return Y({
+    signature: "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+    filters: e
+  });
+}
+function Ma() {
+  return Y({
+    signature: "event SeedPublished(bytes returnedDataFromEAS)"
+  });
+}
+async function jr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xb0d691fe",
+      [],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function Gr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xc45a0155",
+      [],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function Yr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x8b52d723",
+      [],
+      [
+        {
+          type: "tuple[]",
+          name: "signers",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "startTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "endTimestamp"
+            }
+          ]
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function Jr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xe9523c97",
+      [],
+      [
+        {
+          type: "address[]"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function zr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x4a00cc48",
+      [],
+      [
+        {
+          type: "tuple[]",
+          components: [
+            {
+              type: "tuple",
+              name: "metadata",
+              components: [
+                {
+                  type: "string",
+                  name: "name"
+                },
+                {
+                  type: "string",
+                  name: "metadataURI"
+                },
+                {
+                  type: "address",
+                  name: "implementation"
+                }
+              ]
+            },
+            {
+              type: "tuple[]",
+              name: "functions",
+              components: [
+                {
+                  type: "bytes4",
+                  name: "functionSelector"
+                },
+                {
+                  type: "string",
+                  name: "functionSignature"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function Zr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xd42f2f35",
+      [],
+      [
+        {
+          type: "tuple[]",
+          name: "signers",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "startTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "endTimestamp"
+            }
+          ]
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function Kr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xce0b6013",
+      [
+        {
+          type: "bytes4",
+          name: "_functionSelector"
+        }
+      ],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: [e.functionSelector]
+  });
+}
+async function Qr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xd087d288",
+      [],
+      [
+        {
+          type: "uint256"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function Xr(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xf15d424e",
+      [
+        {
+          type: "address",
+          name: "signer"
+        }
+      ],
+      [
+        {
+          type: "tuple",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "startTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "endTimestamp"
+            }
+          ]
+        }
+      ]
+    ],
+    params: [e.signer]
+  });
+}
+async function eo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x7dff5a79",
+      [
+        {
+          type: "address",
+          name: "signer"
+        }
+      ],
+      [
+        {
+          type: "bool"
+        }
+      ]
+    ],
+    params: [e.signer]
+  });
+}
+async function to(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x24d7806c",
+      [
+        {
+          type: "address",
+          name: "_account"
+        }
+      ],
+      [
+        {
+          type: "bool"
+        }
+      ]
+    ],
+    params: [e.account]
+  });
+}
+async function no(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x1dd756c5",
+      [
+        {
+          type: "address",
+          name: "_signer"
+        },
+        {
+          type: "tuple",
+          name: "_userOp",
+          components: [
+            {
+              type: "address",
+              name: "sender"
+            },
+            {
+              type: "uint256",
+              name: "nonce"
+            },
+            {
+              type: "bytes",
+              name: "initCode"
+            },
+            {
+              type: "bytes",
+              name: "callData"
+            },
+            {
+              type: "uint256",
+              name: "callGasLimit"
+            },
+            {
+              type: "uint256",
+              name: "verificationGasLimit"
+            },
+            {
+              type: "uint256",
+              name: "preVerificationGas"
+            },
+            {
+              type: "uint256",
+              name: "maxFeePerGas"
+            },
+            {
+              type: "uint256",
+              name: "maxPriorityFeePerGas"
+            },
+            {
+              type: "bytes",
+              name: "paymasterAndData"
+            },
+            {
+              type: "bytes",
+              name: "signature"
+            }
+          ]
+        }
+      ],
+      [
+        {
+          type: "bool"
+        }
+      ]
+    ],
+    params: [e.signer, e.userOp]
+  });
+}
+async function ao(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xa9082d84",
+      [
+        {
+          type: "tuple",
+          name: "req",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "uint8",
+              name: "isAdmin"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "permissionStartTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "permissionEndTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "reqValidityStartTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "reqValidityEndTimestamp"
+            },
+            {
+              type: "bytes32",
+              name: "uid"
+            }
+          ]
+        },
+        {
+          type: "bytes",
+          name: "signature"
+        }
+      ],
+      [
+        {
+          type: "bool",
+          name: "success"
+        },
+        {
+          type: "address",
+          name: "signer"
+        }
+      ]
+    ],
+    params: [e.req, e.signature]
+  });
+}
+async function so(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xe8a3d485",
+      [],
+      [
+        {
+          type: "string"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function ro(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x399b77da",
+      [
+        {
+          type: "bytes32",
+          name: "_hash"
+        }
+      ],
+      [
+        {
+          type: "bytes32"
+        }
+      ]
+    ],
+    params: [e.hash]
+  });
+}
+async function oo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x1626ba7e",
+      [
+        {
+          type: "bytes32",
+          name: "_hash"
+        },
+        {
+          type: "bytes",
+          name: "_signature"
+        }
+      ],
+      [
+        {
+          type: "bytes4",
+          name: "magicValue"
+        }
+      ]
+    ],
+    params: [e.hash, e.signature]
+  });
+}
+async function io(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x01ffc9a7",
+      [
+        {
+          type: "bytes4",
+          name: "interfaceId"
+        }
+      ],
+      [
+        {
+          type: "bool"
+        }
+      ]
+    ],
+    params: [e.interfaceId]
+  });
+}
+async function co(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x84b0196e",
+      [],
+      [
+        {
+          type: "bytes1",
+          name: "fields"
+        },
+        {
+          type: "string",
+          name: "name"
+        },
+        {
+          type: "string",
+          name: "version"
+        },
+        {
+          type: "uint256",
+          name: "chainId"
+        },
+        {
+          type: "address",
+          name: "verifyingContract"
+        },
+        {
+          type: "bytes32",
+          name: "salt"
+        },
+        {
+          type: "uint256[]",
+          name: "extensions"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function lo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0xd5f5127d",
+      [],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+async function uo(e) {
+  return _({
+    contract: e.contract,
+    method: [
+      "0x8da5cb5b",
+      [],
+      [
+        {
+          type: "address"
+        }
+      ]
+    ],
+    params: []
+  });
+}
+function po(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xd1f57894",
+      [
+        {
+          type: "address",
+          name: "_defaultAdmin"
+        },
+        {
+          type: "bytes",
+          name: "_data"
+        }
+      ],
+      []
+    ],
+    params: [e.defaultAdmin, e.data]
+  });
+}
+function mo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xac9650d8",
+      [
+        {
+          type: "bytes[]",
+          name: "data"
+        }
+      ],
+      [
+        {
+          type: "bytes[]",
+          name: "results"
+        }
+      ]
+    ],
+    params: [e.data]
+  });
+}
+function fo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xb76464d5",
+      [
+        {
+          type: "address",
+          name: "_entrypointOverride"
+        }
+      ],
+      []
+    ],
+    params: [e.entrypointOverride]
+  });
+}
+function ho(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x5892e236",
+      [
+        {
+          type: "tuple",
+          name: "_req",
+          components: [
+            {
+              type: "address",
+              name: "signer"
+            },
+            {
+              type: "uint8",
+              name: "isAdmin"
+            },
+            {
+              type: "address[]",
+              name: "approvedTargets"
+            },
+            {
+              type: "uint256",
+              name: "nativeTokenLimitPerTransaction"
+            },
+            {
+              type: "uint128",
+              name: "permissionStartTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "permissionEndTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "reqValidityStartTimestamp"
+            },
+            {
+              type: "uint128",
+              name: "reqValidityEndTimestamp"
+            },
+            {
+              type: "bytes32",
+              name: "uid"
+            }
+          ]
+        },
+        {
+          type: "bytes",
+          name: "_signature"
+        }
+      ],
+      []
+    ],
+    params: [e.req, e.signature]
+  });
+}
+function yo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x3a871cdd",
+      [
+        {
+          type: "tuple",
+          name: "userOp",
+          components: [
+            {
+              type: "address",
+              name: "sender"
+            },
+            {
+              type: "uint256",
+              name: "nonce"
+            },
+            {
+              type: "bytes",
+              name: "initCode"
+            },
+            {
+              type: "bytes",
+              name: "callData"
+            },
+            {
+              type: "uint256",
+              name: "callGasLimit"
+            },
+            {
+              type: "uint256",
+              name: "verificationGasLimit"
+            },
+            {
+              type: "uint256",
+              name: "preVerificationGas"
+            },
+            {
+              type: "uint256",
+              name: "maxFeePerGas"
+            },
+            {
+              type: "uint256",
+              name: "maxPriorityFeePerGas"
+            },
+            {
+              type: "bytes",
+              name: "paymasterAndData"
+            },
+            {
+              type: "bytes",
+              name: "signature"
+            }
+          ]
+        },
+        {
+          type: "bytes32",
+          name: "userOpHash"
+        },
+        {
+          type: "uint256",
+          name: "missingAccountFunds"
+        }
+      ],
+      [
+        {
+          type: "uint256",
+          name: "validationData"
+        }
+      ]
+    ],
+    params: [e.userOp, e.userOpHash, e.missingAccountFunds]
+  });
+}
+function go(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x4a58db19",
+      [],
+      []
+    ],
+    params: []
+  });
+}
+function wo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xb61d27f6",
+      [
+        {
+          type: "address",
+          name: "_target"
+        },
+        {
+          type: "uint256",
+          name: "_value"
+        },
+        {
+          type: "bytes",
+          name: "_calldata"
+        }
+      ],
+      []
+    ],
+    params: [e.target, e.value, e.calldata]
+  });
+}
+function bo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x47e1da2a",
+      [
+        {
+          type: "address[]",
+          name: "_target"
+        },
+        {
+          type: "uint256[]",
+          name: "_value"
+        },
+        {
+          type: "bytes[]",
+          name: "_calldata"
+        }
+      ],
+      []
+    ],
+    params: [e.target, e.value, e.calldata]
+  });
+}
+function Ao(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xbc197c81",
+      [
+        {
+          type: "address"
+        },
+        {
+          type: "address"
+        },
+        {
+          type: "uint256[]"
+        },
+        {
+          type: "uint256[]"
+        },
+        {
+          type: "bytes"
+        }
+      ],
+      [
+        {
+          type: "bytes4"
+        }
+      ]
+    ],
+    params: [e.arg_0, e.arg_1, e.arg_2, e.arg_3, e.arg_4]
+  });
+}
+function vo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xf23a6e61",
+      [
+        {
+          type: "address"
+        },
+        {
+          type: "address"
+        },
+        {
+          type: "uint256"
+        },
+        {
+          type: "uint256"
+        },
+        {
+          type: "bytes"
+        }
+      ],
+      [
+        {
+          type: "bytes4"
+        }
+      ]
+    ],
+    params: [e.arg_0, e.arg_1, e.arg_2, e.arg_3, e.arg_4]
+  });
+}
+function So(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x150b7a02",
+      [
+        {
+          type: "address"
+        },
+        {
+          type: "address"
+        },
+        {
+          type: "uint256"
+        },
+        {
+          type: "bytes"
+        }
+      ],
+      [
+        {
+          type: "bytes4"
+        }
+      ]
+    ],
+    params: [e.arg_0, e.arg_1, e.arg_2, e.arg_3]
+  });
+}
+function Eo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x938e3d7b",
+      [
+        {
+          type: "string",
+          name: "_uri"
+        }
+      ],
+      []
+    ],
+    params: [e.uri]
+  });
+}
+function Io(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x4d44560d",
+      [
+        {
+          type: "address",
+          name: "withdrawAddress"
+        },
+        {
+          type: "uint256",
+          name: "amount"
+        }
+      ],
+      []
+    ],
+    params: [e.withdrawAddress, e.amount]
+  });
+}
+function Po(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x6240d6d9",
+      [
+        {
+          type: "bytes32",
+          name: "schemaUid"
+        },
+        {
+          type: "bool",
+          name: "revocable"
+        }
+      ],
+      [
+        {
+          type: "bytes32"
+        }
+      ]
+    ],
+    params: [e.schemaUid, e.revocable]
+  });
+}
+function Uo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x13e0c263",
+      [
+        {
+          type: "bytes32",
+          name: "seedUid"
+        },
+        {
+          type: "bytes32",
+          name: "versionSchemaUid"
+        }
+      ],
+      [
+        {
+          type: "bytes32"
+        }
+      ]
+    ],
+    params: [e.seedUid, e.versionSchemaUid]
+  });
+}
+function bt(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x31e19cb8",
+      [
+        {
+          type: "tuple[]",
+          name: "requests",
+          components: [
+            {
+              type: "string",
+              name: "localId"
+            },
+            {
+              type: "bytes32",
+              name: "seedUid"
+            },
+            {
+              type: "bytes32",
+              name: "seedSchemaUid"
+            },
+            {
+              type: "bytes32",
+              name: "versionUid"
+            },
+            {
+              type: "bytes32",
+              name: "versionSchemaUid"
+            },
+            {
+              type: "bool",
+              name: "seedIsRevocable"
+            },
+            {
+              type: "tuple[]",
+              name: "listOfAttestations",
+              components: [
+                {
+                  type: "bytes32",
+                  name: "schema"
+                },
+                {
+                  type: "tuple[]",
+                  name: "data",
+                  components: [
+                    {
+                      type: "address",
+                      name: "recipient"
+                    },
+                    {
+                      type: "uint64",
+                      name: "expirationTime"
+                    },
+                    {
+                      type: "bool",
+                      name: "revocable"
+                    },
+                    {
+                      type: "bytes32",
+                      name: "refUID"
+                    },
+                    {
+                      type: "bytes",
+                      name: "data"
+                    },
+                    {
+                      type: "uint256",
+                      name: "value"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "tuple[]",
+              name: "propertiesToUpdate",
+              components: [
+                {
+                  type: "string",
+                  name: "publishLocalId"
+                },
+                {
+                  type: "bytes32",
+                  name: "propertySchemaUid"
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      [
+        {
+          type: "bytes32[]"
+        }
+      ]
+    ],
+    params: [e.requests]
+  });
+}
+function To(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xd688e801",
+      [
+        {
+          type: "tuple[]",
+          name: "requests",
+          components: [
+            { type: "uint256", name: "localIdIndex" },
+            { type: "bytes32", name: "seedUid" },
+            { type: "bytes32", name: "seedSchemaUid" },
+            { type: "bytes32", name: "versionUid" },
+            { type: "bytes32", name: "versionSchemaUid" },
+            { type: "bool", name: "seedIsRevocable" },
+            {
+              type: "tuple[]",
+              name: "listOfAttestations",
+              components: [
+                { type: "bytes32", name: "schema" },
+                {
+                  type: "tuple[]",
+                  name: "data",
+                  components: [
+                    { type: "address", name: "recipient" },
+                    { type: "uint64", name: "expirationTime" },
+                    { type: "bool", name: "revocable" },
+                    { type: "bytes32", name: "refUID" },
+                    { type: "bytes", name: "data" },
+                    { type: "uint256", name: "value" }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "tuple[]",
+              name: "propertiesToUpdate",
+              components: [
+                { type: "uint256", name: "publishLocalIdIndex" },
+                { type: "bytes32", name: "propertySchemaUid" }
+              ]
+            }
+          ]
+        }
+      ],
+      [{ type: "bytes32[]" }]
+    ],
+    params: [e.requests]
+  });
+}
+function Do(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xb71308c5",
+      [
+        {
+          type: "tuple",
+          name: "request",
+          components: [
+            {
+              type: "string",
+              name: "localId"
+            },
+            {
+              type: "bytes32",
+              name: "seedUid"
+            },
+            {
+              type: "bytes32",
+              name: "seedSchemaUid"
+            },
+            {
+              type: "bytes32",
+              name: "versionUid"
+            },
+            {
+              type: "bytes32",
+              name: "versionSchemaUid"
+            },
+            {
+              type: "bool",
+              name: "seedIsRevocable"
+            },
+            {
+              type: "tuple[]",
+              name: "listOfAttestations",
+              components: [
+                {
+                  type: "bytes32",
+                  name: "schema"
+                },
+                {
+                  type: "tuple[]",
+                  name: "data",
+                  components: [
+                    {
+                      type: "address",
+                      name: "recipient"
+                    },
+                    {
+                      type: "uint64",
+                      name: "expirationTime"
+                    },
+                    {
+                      type: "bool",
+                      name: "revocable"
+                    },
+                    {
+                      type: "bytes32",
+                      name: "refUID"
+                    },
+                    {
+                      type: "bytes",
+                      name: "data"
+                    },
+                    {
+                      type: "uint256",
+                      name: "value"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "tuple[]",
+              name: "propertiesToUpdate",
+              components: [
+                {
+                  type: "string",
+                  name: "publishLocalId"
+                },
+                {
+                  type: "bytes32",
+                  name: "propertySchemaUid"
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      [
+        {
+          type: "bytes32"
+        },
+        {
+          type: "bytes32"
+        }
+      ]
+    ],
+    params: [e.request]
+  });
+}
+function xo(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0x715018a6",
+      [],
+      []
+    ],
+    params: []
+  });
+}
+function Co(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xb90b6e0d",
+      [
+        {
+          type: "address",
+          name: "_eas"
+        }
+      ],
+      [
+        {
+          type: "string"
+        }
+      ]
+    ],
+    params: [e.eas]
+  });
+}
+function Ro(e) {
+  return x({
+    contract: e.contract,
+    method: [
+      "0xf2fde38b",
+      [
+        {
+          type: "address",
+          name: "newOwner"
+        }
+      ],
+      []
+    ],
+    params: [e.newOwner]
+  });
+}
+const _e = () => {
+  const e = xn.getHost(), t = Qn;
+  return Object.keys(t).includes("default") && t.default ? t.default.init({
+    host: e,
+    protocol: "https"
+  }) : t.init({
+    host: e,
+    protocol: "https"
+  });
+}, $ = "0x" + "0".repeat(64), ct = async (e) => {
+  let t;
+  try {
+    t = await ae.find({ seedLocalId: e });
+  } catch {
+  }
+  return t || new Promise((n) => {
+    const a = setInterval(() => {
+      try {
+        ae.find({ seedLocalId: e }).then((s) => {
+          s && (clearInterval(a), n(s));
+        });
+      } catch {
+      }
+    }, 200);
+  });
+};
+function Oa(e) {
+  if (!e || typeof e != "object") return;
+  const t = e;
+  if (Array.isArray(t.data_root))
+    return {
+      data_root: new Uint8Array(t.data_root),
+      chunks: (t.chunks ?? []).map((n) => ({ ...n, dataHash: new Uint8Array(n.dataHash ?? []) })),
+      proofs: (t.proofs ?? []).map((n) => ({ ...n, proof: new Uint8Array(n.proof ?? []) }))
+    };
+}
+function Ba(e) {
+  return {
+    data_root: Array.from(e.data_root),
+    chunks: e.chunks.map((t) => ({ ...t, dataHash: Array.from(t.dataHash) })),
+    proofs: e.proofs.map((t) => ({ ...t, proof: Array.from(t.proof) }))
+  };
+}
+const Fa = he(
+  async ({ input: { context: e } }) => {
+    let { item: t } = e;
+    t.getPublishUploads || (t = await ct(t.seedLocalId));
+    const n = await t.getPublishUploads(), a = C(), s = e.signArweaveTransactions ?? a.signArweaveTransactions, r = e.arweaveJwk ?? a.arweaveJwk, o = n.map((d) => ({
+      versionLocalId: d.versionLocalId,
+      itemPropertyName: d.itemPropertyName,
+      transactionJson: d.transactionToSign.toJSON()
+    }));
+    let i;
+    if (s)
+      i = await s(o);
+    else if (r) {
+      const d = _e(), p = r;
+      i = [];
+      for (const l of o) {
+        const m = d.transactions.fromRaw(l.transactionJson);
+        m.data && m.data.byteLength > 0 && !m.chunks && await m.prepareChunks(m.data), await d.transactions.sign(m, p);
+        const h = m.toJSON();
+        i.push({
+          transaction: {
+            ...h,
+            chunks: m.chunks ? Ba(m.chunks) : void 0
+          },
+          versionId: l.versionLocalId,
+          modelName: l.itemPropertyName
+        });
+      }
+    } else
+      throw new Error(
+        "Arweave signing not configured. Provide signArweaveTransactions or arweaveJwk at createPublish or in PublishProvider config."
+      );
+    const c = _e();
+    return {
+      arweaveTransactions: i.map((d) => {
+        const { chunks: p, ...l } = d.transaction, m = { ...l }, h = Oa(p);
+        return h && (m.chunks = h), {
+          transaction: c.transactions.fromRaw(m),
+          versionId: d.versionId,
+          modelName: d.modelName
+        };
+      }),
+      publishUploads: n
+    };
+  }
+), zt = async (e) => {
+  const t = e instanceof Uint8Array ? new Uint8Array(e) : new Uint8Array(e), n = await crypto.subtle.digest("SHA-256", t);
+  return Array.from(new Uint8Array(n)).map((a) => a.toString(16).padStart(2, "0")).join("");
+}, Na = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  html: "text/html",
+  htm: "text/html",
+  json: "application/json",
+  txt: "text/plain"
+}, Zt = (e) => {
+  const t = e.split(".").pop()?.toLowerCase();
+  return t ? Na[t] : void 0;
+}, tt = async (e) => typeof Blob < "u" && e instanceof Blob ? new Uint8Array(await e.arrayBuffer()) : new Uint8Array(e), ka = (e) => {
+  switch (e) {
+    case "Image":
+      return G.getFilesPath("images");
+    case "File":
+      return G.getFilesPath("files");
+    case "Html":
+      return G.getFilesPath("html");
+    case "Json":
+      return G.getFilesPath("json");
+    default:
+      return G.getFilesPath("images");
+  }
+}, Ha = async (e, t, n) => {
+  const a = e.itemProperty, s = [];
+  for (const p of e.childProperties) {
+    const l = p.localStoragePath;
+    !l || l.endsWith("undefined") || !await G.pathExists(l) || s.push({
+      propertyName: p.propertyName,
+      localStoragePath: l
+    });
+  }
+  let r;
+  if ((!s || s.length === 0) && n?.localStoragePath) {
+    const p = n.localStoragePath;
+    if (p && !p.endsWith("undefined") && await G.pathExists(p))
+      try {
+        const m = await G.readFileAsBuffer(p);
+        r = await tt(m);
+      } catch {
+        const m = await G.getFs();
+        r = await tt(m.readFileSync(p));
+      }
+  }
+  if (s.length > 0) {
+    const p = "===FILE_SEPARATOR===";
+    let l = "";
+    const m = await G.getFs();
+    for (const h of s) {
+      let y;
+      try {
+        y = await m.promises.readFile(h.localStoragePath);
+      } catch {
+        y = m.readFileSync(h.localStoragePath);
+      }
+      l += `${p}${h.propertyName}${p}${y}`;
+    }
+    r = typeof document < "u" ? new TextEncoder().encode(l) : new Uint8Array(Buffer.from(l));
+  }
+  if (!r) return t;
+  const o = new Uint8Array(r), i = await zt(o);
+  let c;
+  s.length === 0 && n?.localStoragePath ? c = Zt(n.localStoragePath) : s.length > 0 && (c = "application/octet-stream");
+  const u = n ? n.localId : a.localId, d = n ? n.propertyName : a.propertyName;
+  return t.push({
+    data: o,
+    contentHash: i,
+    contentType: c,
+    itemPropertyName: d,
+    itemPropertyLocalId: u,
+    seedLocalId: a.seedLocalId,
+    versionLocalId: a.versionLocalId
+  }), t;
+}, $a = async (e) => {
+  const t = [];
+  for (const n of e) {
+    const a = n.getService().getSnapshot(), s = "context" in a ? a.context : null;
+    if (!s) continue;
+    const r = s.propertyValue, o = s.refResolvedValue;
+    if (!o) continue;
+    const { localId: i } = Mt(r ?? "");
+    if (!i) continue;
+    const c = n.propertyDef?.refValueType ?? n.propertyDef?.dataType ?? "Image", d = `${ka(c)}/${o}`;
+    if (!await G.pathExists(d)) continue;
+    const l = await G.readFileAsBuffer(d), m = await tt(l), h = await zt(m), y = Zt(o);
+    t.push({
+      data: m,
+      contentHash: h,
+      contentType: y,
+      itemPropertyName: n.propertyName,
+      itemPropertyLocalId: n.localId,
+      seedLocalId: i,
+      versionLocalId: n.versionLocalId
+    });
+  }
+  return t;
+}, Kt = async (e, t = [], n) => {
+  const { itemUploadProperties: a, itemRelationProperties: s, itemImageProperties: r } = await at(e);
+  for (const i of a)
+    t = await Ha(i, t, n);
+  const o = await $a(r);
+  t.push(...o);
+  for (const i of s) {
+    const c = i.getService().getSnapshot(), u = "context" in c ? c.context : null;
+    if (!u) continue;
+    const d = u.propertyValue;
+    if (!d || i.uid) continue;
+    const { localId: p, uid: l } = Mt(d), m = await ae.find({ seedLocalId: p, seedUid: l });
+    if (!m)
+      throw new Error(`No relatedItem found for ${i.propertyName}`);
+    t = await Kt(m, t, i);
+  }
+  return t;
+}, dt = 3, pe = 65, At = new TextEncoder().encode("seed-recovery");
+function Va(e) {
+  return e != null && typeof e == "object" && "privateKey" in e && typeof e.privateKey == "string";
+}
+function Wa(e, t, n) {
+  let s = e >= 0 ? e << 1 : ~e << 1 | 1, r = n;
+  do {
+    const o = s & 127;
+    s >>>= 7, t[r++] = s ? o | 128 : o;
+  } while (s);
+  return r - n;
+}
+const lt = (e) => {
+  if (!e?.length) return new Uint8Array(0);
+  const t = new TextEncoder(), n = new Uint8Array(16), a = [], s = (c) => {
+    const u = Wa(c, n, 0);
+    a.push(n.slice(0, u));
+  };
+  s(e.length);
+  for (const c of e) {
+    const u = t.encode(c.name), d = t.encode(c.value);
+    s(u.length), a.push(u), s(d.length), a.push(d);
+  }
+  s(0);
+  const r = a.reduce((c, u) => c + u.length, 0), o = new Uint8Array(r);
+  let i = 0;
+  for (const c of a)
+    o.set(c, i), i += c.length;
+  return o;
+}, vt = (e) => {
+  const t = new Uint8Array(8), n = new DataView(t.buffer);
+  return n.setUint32(0, e & 4294967295, !0), n.setUint32(4, Math.floor(e / 4294967296), !0), t;
+};
+async function we(e) {
+  return new Uint8Array(
+    await crypto.subtle.digest("SHA-384", e)
+  );
+}
+function Ie(e, t) {
+  const n = new Uint8Array(e.length + t.length);
+  return n.set(e, 0), n.set(t, e.length), n;
+}
+async function Qt(e) {
+  const t = new TextEncoder();
+  if (Array.isArray(e)) {
+    const r = Ie(t.encode("list"), t.encode(e.length.toString()));
+    let o = await we(r);
+    for (const i of e) {
+      const c = await Qt(i);
+      o = await we(Ie(o, c));
+    }
+    return o;
+  }
+  const n = Ie(t.encode("blob"), t.encode(e.byteLength.toString())), a = await we(n), s = await we(e);
+  return we(Ie(a, s));
+}
+async function ut(e, t, n, a, s) {
+  const r = new TextEncoder();
+  return Qt([
+    r.encode("dataitem"),
+    r.encode("1"),
+    r.encode(dt.toString()),
+    e,
+    t,
+    n,
+    a,
+    s
+  ]);
+}
+function Xt(e, t, n) {
+  const a = lt(t), s = vt(t.length), r = vt(a.length), o = new Uint8Array([0]), i = new Uint8Array([0]), c = [
+    e,
+    o,
+    i,
+    s,
+    r,
+    a,
+    n
+  ], u = c.reduce((l, m) => l + m.length, 0), d = new Uint8Array(u);
+  let p = 0;
+  for (const l of c)
+    d.set(l, p), p += l.length;
+  return d;
+}
+async function en(e, t) {
+  const n = new Uint8Array(2);
+  new DataView(n.buffer).setUint16(0, dt, !0);
+  const a = 2 + pe + t.length, s = new Uint8Array(a);
+  s.set(n, 0), s.set(e, 2), s.set(t, 2 + pe);
+  const r = await crypto.subtle.digest("SHA-256", new Uint8Array(e));
+  return { id: Ya(new Uint8Array(r)), raw: s };
+}
+const qa = async (e, t, n) => {
+  const a = H.SigningKey.computePublicKey(t.privateKey, !1), s = H.getBytes(a), r = lt(n), o = new Uint8Array(0), i = new Uint8Array(0), c = await ut(
+    s,
+    o,
+    i,
+    r,
+    e
+  ), u = H.getBytes(await t.signMessage(c)), d = Xt(s, n, e);
+  return en(u, d);
+}, ja = async (e, t, n) => {
+  const a = H.hexlify(At), s = await t.signMessage({
+    message: { raw: a }
+  }), r = H.hashMessage(At), o = H.SigningKey.recoverPublicKey(r, s), i = H.getBytes(o), c = lt(n), u = new Uint8Array(0), d = new Uint8Array(0), p = await ut(
+    i,
+    u,
+    d,
+    c,
+    e
+  ), l = H.hexlify(p), m = await t.signMessage({
+    message: { raw: l }
+  }), h = H.getBytes(m), y = Xt(i, n, e);
+  return en(h, y);
+};
+async function Ga(e) {
+  const t = 2 + pe + 65 + 1 + 1, n = t + 16;
+  if (e.length < n) return !1;
+  const a = new DataView(e.buffer, e.byteOffset, e.byteLength);
+  if (a.getUint16(0, !0) !== dt) return !1;
+  const r = e.slice(2, 2 + pe), o = e.slice(2 + pe, 2 + pe + 65), i = new Uint8Array(0), c = new Uint8Array(0), u = Number(
+    a.getUint32(t + 8, !0) + a.getUint32(t + 12, !0) * 4294967296
+  ), d = t + 16 + u;
+  if (e.length < d) return !1;
+  const p = e.slice(t + 16, d), l = e.slice(d);
+  try {
+    const m = await ut(
+      o,
+      i,
+      c,
+      p,
+      l
+    ), h = H.hashMessage(m), y = H.hexlify(r), f = H.SigningKey.recoverPublicKey(h, y), A = H.getBytes(f);
+    return A.length === o.length && A.every((g, I) => g === o[I]);
+  } catch {
+    return !1;
+  }
+}
+const Ya = (e) => {
+  let t = "";
+  for (const n of e)
+    t += String.fromCharCode(n);
+  return btoa(t).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}, Ja = K("seedProtocol:createArweaveDataItems"), za = he(
+  async ({ input: { context: e } }) => {
+    let { item: t } = e;
+    t.getPublishUploads || (t = await ct(t.seedLocalId));
+    const n = await Kt(t), a = C(), s = e.signDataItems ?? a.signDataItems, r = e.dataItemSigner ?? a.dataItemSigner;
+    let o, i;
+    if (s)
+      o = (await s(n)).map((d) => ({
+        transaction: { id: d.transaction.id },
+        versionId: d.versionId,
+        modelName: d.modelName
+      }));
+    else if (r) {
+      const u = r, d = [];
+      for (const p of n) {
+        const l = [];
+        p.contentHash && l.push({ name: "Content-SHA-256", value: p.contentHash }), p.contentType && l.push({ name: "Content-Type", value: p.contentType });
+        const m = Va(u) ? await qa(p.data, u, l) : await ja(p.data, u, l);
+        if (!await Ga(m.raw))
+          throw Ja("DataItem verification failed: id=%s modelName=%s", m.id, p.itemPropertyName), new Error(
+            `DataItem signature verification failed for ${p.itemPropertyName}. The signing key may not match the owner, or the payload may have been modified.`
+          );
+        d.push(m);
+      }
+      i = d, o = d.map((p, l) => ({
+        transaction: { id: p.id },
+        versionId: n[l]?.versionLocalId,
+        modelName: n[l]?.itemPropertyName
+      }));
+    } else
+      throw new Error(
+        "@seedprotocol/publish: useArweaveBundler requires signDataItems or dataItemSigner (pass at createPublish or in PublishProvider config)"
+      );
+    const c = n.map((u) => ({
+      itemPropertyName: u.itemPropertyName,
+      itemPropertyLocalId: u.itemPropertyLocalId,
+      seedLocalId: u.seedLocalId,
+      versionLocalId: u.versionLocalId,
+      transactionToSign: null
+    }));
+    return {
+      arweaveTransactions: o,
+      publishUploads: c,
+      arweaveUploadData: n,
+      signedDataItems: i
+    };
+  }
+), St = 8192;
+function Za(e) {
+  const t = new Uint8Array(e);
+  let n = "";
+  for (let a = 0; a < t.length; a += St) {
+    const s = t.subarray(a, Math.min(a + St, t.length));
+    n += String.fromCharCode.apply(null, s);
+  }
+  return btoa(n);
+}
+async function Ka(e) {
+  const t = [];
+  for (const [n, a] of e.entries()) {
+    const s = a;
+    if (typeof s == "object" && s !== null && "arrayBuffer" in s) {
+      const r = await s.arrayBuffer(), o = Za(r), i = s;
+      t.push({
+        name: n,
+        value: o,
+        encoding: "base64",
+        filename: i.name || void 0
+      });
+    } else
+      t.push({ name: n, value: String(a) });
+  }
+  return t;
+}
+function Qa(e, t, n) {
+  const a = ["Upload server returned ", String(e)], s = t && typeof t == "object" && "message" in t ? String(t.message) : t && typeof t == "object" && "error" in t ? String(t.error) : null;
+  return s ? a.push(`: ${s}`) : n && a.push(` (${n})`), a.join("");
+}
+function Xa(e) {
+  if (!e)
+    return "Upload server unavailable. Please try again or check your connection.";
+  const t = e.toLowerCase();
+  return /other side closed|econnreset|socket hang up|connection closed/i.test(t) ? "Upload server closed the connection. It may be busy or the request may be too large—try again." : /etimedout|timeout/i.test(t) ? "Upload request timed out. Please try again." : /enotfound|getaddrinfo|dns/i.test(t) ? "Upload server could not be reached. Check the upload URL and your network." : "Upload failed. Please try again or check the upload server.";
+}
+async function es(e, t, n) {
+  const a = typeof window < "u" ? window.Main : void 0;
+  if (a?.uploadArweaveStart) {
+    const o = await Ka(t);
+    return a.uploadArweaveStart(e, o);
+  }
+  const s = await fetch(e, {
+    method: "POST",
+    body: t
+  }), r = await s.json().catch(() => ({}));
+  return { status: s.status, body: r };
+}
+const ts = he(
+  async ({ input: { context: e, event: t } }) => {
+    const { arweaveTransactions: n = [], transactionKeys: a, reimbursementTransactionId: s } = e;
+    if (s)
+      return {
+        transactionId: s
+      };
+    const r = n.map(({ transaction: l }) => l), o = new FormData();
+    for (const l of r) {
+      let { data: m, chunks: h, ...y } = l;
+      const f = m instanceof Blob ? m : new Blob([m]);
+      o.append(`${l.id}-data`, f, `${l.id}-data`);
+      const A = new Blob([JSON.stringify(h)], { type: "application/json" });
+      o.append(`${l.id}-chunks`, A, `${l.id}-chunks`);
+      const g = new Blob([JSON.stringify(y)], { type: "application/json" });
+      o.append(`${l.id}-json`, g, `${l.id}-json`);
+    }
+    const { uploadApiBaseUrl: i } = C(), c = `${i}/api/upload/arweave/start`, { status: u, body: d, message: p } = await es(
+      c,
+      o
+    );
+    if (u >= 300 || u < 200) {
+      const l = u === 0 ? p : null;
+      l && console.error("[upload]", l);
+      const m = u === 0 ? Xa(l) : Qa(u, d, a);
+      throw new Error(m);
+    }
+    return d;
+  }
+), ns = he(async ({ input: { context: e, event: t } }) => {
+  const { requestResponse: n, reimbursementTransactionId: a } = e;
+  if (!n)
+    throw new Error("No request response");
+  if (!a)
+    throw new Error("No reimbursement transaction id");
+  const s = _e();
+  await new Promise((o, i) => {
+    const c = setInterval(async () => {
+      let u;
+      try {
+        u = await s.transactions.getStatus(a);
+      } catch {
+        return;
+      }
+      u && u.confirmed && (clearInterval(c), o());
+    }, 5e3);
+  });
+}), ne = K("seedProtocol:services:publish:actors");
+function as(e) {
+  if (e instanceof Uint8Array) return e;
+  if (e instanceof ArrayBuffer) return new Uint8Array(e);
+  throw new Error("Transaction data must be Uint8Array or ArrayBuffer for upload resume");
+}
+const ss = ye(
+  ({ sendBack: e, input: t }) => {
+    const n = t.context, s = (n.arweaveTransactions ?? []).map(({ transaction: u }) => u), r = _e(), o = n.uploaderState && typeof n.currentTransactionIndex == "number", i = o ? n.currentTransactionIndex : 0;
+    (async () => {
+      const u = s.length;
+      for (let d = i; d < u; d++) {
+        const p = s[d];
+        if (!p) continue;
+        const l = r.transactions.fromRaw(p);
+        if (!await r.transactions.verify(l))
+          throw new Error("Transaction verification failed");
+        let h;
+        const y = n.uploaderState;
+        if (o && d === i && y) {
+          const f = l.data, A = f instanceof Uint8Array ? f : as(f);
+          h = await r.transactions.getUploader(y, A);
+        } else
+          h = await r.transactions.getUploader(l, l.data);
+        for (; !h.isComplete; ) {
+          ne("uploading chunk"), ne(`uploader.pctComplete: ${h.pctComplete}`), ne(`uploader.uploadedChunks: ${h.uploadedChunks}`), ne(`uploader.totalChunks: ${h.totalChunks}`), ne(h.lastResponseError), ne(h.lastResponseStatus);
+          try {
+            await h.uploadChunk();
+            const f = Math.trunc((d + h.pctComplete / 100) / u * 100);
+            e({
+              type: "updatePercentage",
+              completionPercentage: f,
+              uploaderState: h.toJSON(),
+              currentTransactionIndex: d
+            }), ne(`${h.pctComplete}% complete, ${h.uploadedChunks}/${h.totalChunks}`);
+          } catch (f) {
+            ne(f);
+          }
+        }
+      }
+      return "done";
+    })().then((u) => {
+      e({ type: "uploadComplete", result: u });
+    }).catch((u) => {
+      e({ type: "uploadError", error: u });
+    });
+  }
+), rs = ye(
+  ({ sendBack: e, input: { context: t } }) => {
+    const { signedDataItems: n } = t, { uploadApiBaseUrl: a, useArweaveBundler: s } = C();
+    if (!s || !a) {
+      e({
+        type: "uploadError",
+        error: new Error(
+          "Arweave bundler not configured. Set useArweaveBundler and uploadApiBaseUrl."
+        )
+      });
+      return;
+    }
+    const r = `${a.replace(/\/$/, "")}/api/upload/arweave/batch`;
+    if (!n || n.length === 0) {
+      e({ type: "uploadComplete", result: "done" });
+      return;
+    }
+    (async () => {
+      const i = async (f) => {
+        const A = f;
+        if (A.raw != null && (A.raw instanceof Uint8Array || Buffer.isBuffer(A.raw)))
+          return Buffer.from(A.raw);
+        if (typeof A.getRaw == "function") {
+          const g = A.getRaw();
+          return g instanceof Promise ? g : Buffer.from(g);
+        }
+        if (A.filename != null)
+          return Xn(A.filename);
+        throw new Error("Cannot get raw bytes from DataItem");
+      }, c = await Promise.all(
+        n.map((f) => i(f))
+      ), u = c.length;
+      let d = 4;
+      for (const f of c)
+        d += 4 + f.length;
+      const p = Buffer.alloc(d);
+      let l = 0;
+      p.writeUInt32BE(u, l), l += 4;
+      for (const f of c)
+        p.writeUInt32BE(f.length, l), l += 4, f.copy(p, l), l += f.length;
+      const m = await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/octet-stream" },
+        body: p
+      });
+      if (!m.ok)
+        throw new Error(`Batch upload failed: ${m.status}`);
+      const h = await m.json().catch(() => ({})), y = typeof h.failed == "number" ? h.failed : 0;
+      if (y > 0) {
+        const f = h.total ?? "?", A = h.succeeded ?? 0;
+        throw new Error(
+          `Arweave batch upload failed: ${y} of ${f} item(s) failed (${A} succeeded)`
+        );
+      }
+    })().then(() => e({ type: "uploadComplete", result: "done" })).catch((i) => e({ type: "uploadError", error: i }));
+  }
+), tn = "Could not connect the managed publishing account on Optimism Sepolia. Reconnect with the same sign-in method and try again.", os = "Your publishing smart account is not deployed on Optimism Sepolia yet. Complete wallet setup, enable autoDeployManagedAccount in config if appropriate, then try again.", is = "The managed account could not be confirmed on Optimism Sepolia after deployment. Wait a moment and retry, or check your network connection.", nn = "Automatic deployment of the managed publishing account failed on Optimism Sepolia. Retry or deploy the account through your wallet provider.";
+async function Et() {
+  const { useModularExecutor: e } = C();
+  if (!e)
+    return { kind: "skip" };
+  let t;
+  try {
+    t = await rt(v);
+  } catch (a) {
+    return { kind: "unavailable", cause: a };
+  }
+  return await Re(t) ? { kind: "ready", managedAddress: t } : { kind: "not_deployed", managedAddress: t };
+}
+async function an() {
+  const e = Me();
+  await e.autoConnect({ client: R(), chain: v });
+  const t = e.getAccount();
+  if (!t)
+    throw new Q(tn, "MANAGED_ACCOUNT_UNAVAILABLE");
+  return t;
+}
+async function cs() {
+  const e = await an();
+  try {
+    await la(e);
+  } catch (t) {
+    throw new Q(nn, "MANAGED_ACCOUNT_NOT_DEPLOYED", e.address, t);
+  }
+}
+async function sn() {
+  const e = C();
+  if (!e.useModularExecutor)
+    throw new Error("runModularExecutorPublishPrep: useModularExecutor is false");
+  let t = await Et();
+  if (t.kind === "unavailable")
+    return {
+      ok: !1,
+      error: new Q(tn, "MANAGED_ACCOUNT_UNAVAILABLE", void 0, t.cause)
+    };
+  if (t.kind === "not_deployed")
+    if (e.autoDeployManagedAccount) {
+      try {
+        await cs();
+      } catch (n) {
+        return { ok: !1, error: wt(n) ? n : new Q(nn, "MANAGED_ACCOUNT_NOT_DEPLOYED", t.managedAddress, n) };
+      }
+      if (t = await Et(), t.kind !== "ready")
+        return {
+          ok: !1,
+          error: new Q(
+            is,
+            "MANAGED_ACCOUNT_NOT_DEPLOYED",
+            t.kind === "not_deployed" ? t.managedAddress : void 0
+          )
+        };
+    } else
+      return {
+        ok: !1,
+        error: new Q(os, "MANAGED_ACCOUNT_NOT_DEPLOYED", t.managedAddress)
+      };
+  if (t.kind === "ready") {
+    if (e.modularAccountModuleContract)
+      try {
+        const n = await an();
+        await et(t.managedAddress, n, e);
+      } catch (n) {
+        return wt(n) ? { ok: !1, error: n } : {
+          ok: !1,
+          error: new Q(
+            "Executor module setup failed on Optimism Sepolia.",
+            "EXECUTOR_MODULE_NOT_INSTALLED",
+            t.managedAddress,
+            n
+          )
+        };
+      }
+    return { ok: !0, managedAddress: t.managedAddress };
+  }
+  throw new Error("runModularExecutorPublishPrep: unexpected readiness state");
+}
+const ds = K("seedProtocol:services:publish:actors:persistSeedUid"), It = "0x" + "0".repeat(64), ls = 15e3;
+function rn(e, t) {
+  const n = e.seedLocalId, a = n ? t.find((r) => r?.localId === n) : void 0, s = a?.seedUid && a.seedUid !== It ? a.seedUid : t[0]?.seedUid;
+  s && s !== It && (e.seedUid = s);
+}
+async function on(e, t) {
+  const n = e.persistSeedUid;
+  if (typeof n != "function") return;
+  const a = new Promise(
+    (s, r) => setTimeout(() => r(new Error("persistSeedUid timed out")), ls)
+  );
+  try {
+    await Promise.race([n.call(e, t), a]);
+  } catch (s) {
+    ds("persistSeedUid failed (attestations already on-chain):", s);
+  }
+}
+async function cn(e) {
+  if (e.length === 0) return;
+  const { arweaveUploadVerificationBaseUrl: t } = C(), n = await Promise.all(
+    e.map(
+      (a) => Cn(t, a)
+    )
+  );
+  for (let a = 0; a < e.length; a++) {
+    const s = e[a], r = n[a];
+    if (r) {
+      if (r.status === 404)
+        throw new Error(
+          `Arweave transaction ${s} not found. Upload may have failed. Delete this publish record and try again.`
+        );
+      if (r.status !== 200)
+        throw new Error(
+          `Arweave transaction ${s} is not yet available from the upload service (status: ${r.status}). Wait and retry.`
+        );
+    }
+  }
+}
+function us() {
+  return Y({
+    signature: "event CreatedAttestation((bytes32 schemaUid, bytes32 attestationUid) result)"
+  });
+}
+function ps() {
+  return Y({
+    signature: "event SeedPublished(bytes32 seedUid, bytes32 versionUid)"
+  });
+}
+function xe(e) {
+  return e == null || e === "" ? $ : ("0x" + (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0").padStart(64, "0").slice(-64)).toLowerCase();
+}
+function Pt(e, t, n) {
+  if (!t || !e.logs?.length) return;
+  const a = xe(t);
+  if (a === $) return;
+  const s = n ? us : La;
+  try {
+    const r = st({
+      logs: e.logs,
+      events: [s()],
+      strict: !1
+    });
+    for (const o of r) {
+      const i = o?.args?.result;
+      if (i?.attestationUid && xe(i.schemaUid) === a) {
+        const c = i.attestationUid;
+        return c && xe(c) !== $ ? c : void 0;
+      }
+    }
+  } catch {
+  }
+}
+function Ut(e, t, n, a) {
+  const s = t.toLowerCase(), r = e.logs?.filter((o) => o.address && o.address.toLowerCase() === s);
+  if (r?.length)
+    try {
+      const c = st({
+        logs: r,
+        events: [(a ? ps : Ma)()],
+        strict: !1
+      })[0];
+      if (!c) return;
+      if (a) {
+        const f = c.args?.seedUid;
+        return f && xe(f) !== $ ? f : void 0;
+      }
+      const d = c.args?.returnedDataFromEAS;
+      if (!d || d === "0x") return;
+      const l = qn([{ type: "bytes32[]" }], d)[0];
+      if (!l?.length) return;
+      const h = l[n];
+      return h && h !== $ ? h : l.length === 1 && l[0] && l[0] !== $ ? l[0] : void 0;
+    } catch {
+      return;
+    }
+}
+const de = 64, j = (e) => {
+  if (e == null) return "0x" + "0".repeat(de);
+  if (typeof e == "string")
+    return "0x" + (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0").padStart(de, "0").slice(-de);
+  if (e instanceof Uint8Array || typeof ArrayBuffer < "u" && e instanceof ArrayBuffer) {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    return "0x" + Array.from(t).map((a) => a.toString(16).padStart(2, "0")).join("").padStart(de, "0").slice(-de);
+  }
+  return "0x" + "0".repeat(de);
+}, ms = (e) => {
+  if (e == null || typeof e == "string" && (e === "" || e === "0x")) return "0x";
+  if (typeof e == "string") {
+    const n = (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0");
+    return "0x" + (n.length % 2 === 1 ? "0" + n : n);
+  }
+  if (e instanceof Uint8Array || typeof ArrayBuffer < "u" && e instanceof ArrayBuffer) {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    return "0x" + Array.from(t).map((n) => n.toString(16).padStart(2, "0")).join("");
+  }
+  return "0x";
+};
+function fs(e) {
+  const t = new Set(
+    e.map((n) => n?.localId).filter((n) => !!n)
+  );
+  return e.some(
+    (n) => (n?.listOfAttestations ?? []).some((a) => {
+      const s = a;
+      return s._unresolvedValue && t.has(s._unresolvedValue) ? !0 : Array.isArray(s._rawListIdsForResolve) ? s._rawListIdsForResolve.some((r) => r && t.has(String(r).trim())) : !1;
+    })
+  );
+}
+function hs(e, t) {
+  return (e ?? []).filter(
+    (n) => n.publishLocalId && t.has(n.publishLocalId)
+  );
+}
+const ys = {
+  recipient: Qe,
+  expirationTime: BigInt(0),
+  revocable: !0,
+  refUID: $,
+  data: $,
+  value: BigInt(0)
+};
+function Ye(e) {
+  const t = (e?.listOfAttestations ?? []).map((a) => {
+    const s = Array.isArray(a?.data) ? a.data : [];
+    return {
+      schema: j(a?.schema),
+      data: s.map((r) => ({
+        ...r,
+        refUID: j(r?.refUID),
+        data: ms(r?.data),
+        expirationTime: r?.expirationTime != null ? BigInt(r.expirationTime) : BigInt(0),
+        value: r?.value != null ? BigInt(r.value) : BigInt(0)
+      }))
+    };
+  }), n = (e?.propertiesToUpdate ?? []).map((a) => ({
+    ...a,
+    propertySchemaUid: j(a?.propertySchemaUid)
+  }));
+  return {
+    ...e,
+    seedUid: j(e?.seedUid),
+    seedSchemaUid: j(e?.seedSchemaUid),
+    versionUid: j(e?.versionUid),
+    versionSchemaUid: j(e?.versionSchemaUid),
+    listOfAttestations: t,
+    propertiesToUpdate: n
+  };
+}
+function Tt(e, t) {
+  for (const n of e)
+    for (const a of n?.propertiesToUpdate ?? []) {
+      const s = a?.publishLocalId, r = j(a?.propertySchemaUid);
+      if (!s || !r) continue;
+      const o = t.get(s);
+      if (!o?.listOfAttestations) continue;
+      const i = o.listOfAttestations.find(
+        (c) => j(c?.schema)?.toLowerCase() === r?.toLowerCase()
+      );
+      i && (!Array.isArray(i.data) || i.data.length === 0) && (i.data = [{ ...ys, refUID: $ }]);
+    }
+}
+const gs = "pending_l1";
+async function dn(e) {
+  const { useArweaveBundler: t } = C();
+  if (!t) return;
+  const n = e.arweaveTransactions ?? [], a = e.publishUploads ?? [];
+  if (n.length === 0 || n.length !== a.length) return;
+  const s = B.getAppDb();
+  if (!s) return;
+  const r = Date.now();
+  for (let o = 0; o < n.length; o++) {
+    const i = n[o], c = a[o];
+    if (!c) continue;
+    const u = i.transaction?.id;
+    if (!(!u || typeof u != "string"))
+      try {
+        await s.insert(De).values({
+          seedLocalId: c.seedLocalId,
+          dataItemId: u,
+          versionLocalId: c.versionLocalId ?? null,
+          itemPropertyName: c.itemPropertyName ?? null,
+          phase: gs,
+          createdAt: r,
+          updatedAt: r
+        }).onConflictDoNothing();
+      } catch {
+      }
+  }
+}
+const ws = K("seedProtocol:services:publish:actors"), bs = he(
+  async ({ input: { context: e, event: t } }) => {
+    const { address: n, account: a } = e, s = e.arweaveTransactions ?? [], r = e.publishUploads ?? [];
+    let { item: o } = e;
+    const { modularAccountModuleContract: i, useModularExecutor: c } = C();
+    if (!n || typeof n != "string" || !n.trim())
+      throw new Error("No wallet address for publish. Connect a wallet and try again.");
+    if (!a)
+      throw new Error("Wallet session is missing. Reconnect your wallet and retry the publish.");
+    if (!o?.seedLocalId)
+      throw new Error(
+        "Attestation recovery failed: Item data is missing. Delete this publish record and try a full publish from the beginning."
+      );
+    typeof o.getPublishUploads != "function" && (o = await ct(o.seedLocalId));
+    const d = s.length, p = r.length;
+    if (d !== p)
+      throw new Error(
+        "Attestation recovery failed: Arweave transaction data is missing or incomplete. Delete this publish record and try a full publish from the beginning."
+      );
+    const l = V({
+      client: R(),
+      chain: v,
+      address: n
+    });
+    let m = c && i ? V({
+      client: R(),
+      chain: v,
+      address: i
+    }) : l;
+    await Oe(o, a, R(), v);
+    const h = s.map(
+      (w, U) => {
+        const b = w.transaction?.id;
+        if (!b || typeof b != "string")
+          throw new Error(
+            "Attestation recovery failed: Arweave transaction data did not survive restore. Delete this publish record and try a full publish from the beginning."
+          );
+        const M = r[U];
+        if (!M) throw new Error("Publish upload index mismatch");
+        return { ...M, txId: b };
+      }
+    );
+    await cn(h.map((w) => w.txId));
+    let y;
+    try {
+      y = await o.getPublishPayload(h, { publishMode: e.publishMode ?? "patch" });
+    } catch (w) {
+      throw w;
+    }
+    const f = Array.isArray(y) ? y : [y];
+    let A = a;
+    if (c) {
+      const w = await sn();
+      if (!w.ok)
+        throw w.error;
+      m = V({
+        client: R(),
+        chain: v,
+        address: ft
+      });
+      const U = ot();
+      await U.autoConnect({ client: R(), chain: v });
+      const F = U.getAccount();
+      if (!F)
+        throw new Error("Failed to get modular account");
+      A = F;
+    }
+    const g = c ? ft : n, I = f.length > 1 && fs(f);
+    let S;
+    if (I) {
+      let w = structuredClone(f);
+      const U = {};
+      for (let b = 0; b < w.length; b++) {
+        w = await mt(w, U);
+        const M = w[b], X = /* @__PURE__ */ new Set([M.localId]), ge = {
+          ...M,
+          propertiesToUpdate: hs(M.propertiesToUpdate, X)
+        }, J = Ye(ge), Be = /* @__PURE__ */ new Map([[J.localId, J]]);
+        Tt([J], Be);
+        const Fe = {
+          ...bt({
+            contract: m,
+            requests: [J]
+          }),
+          gas: 5000000n
+        }, Ne = await N({
+          account: A,
+          transaction: await Promise.resolve(Fe)
+        }), se = await k({
+          client: R(),
+          chain: v,
+          transactionHash: Ne.transactionHash
+        });
+        if (!se)
+          throw new Error("Failed to send transaction");
+        const re = !J.seedUid || j(J.seedUid) === $, fn = J?.listOfAttestations?.length ?? 0, hn = J?.seedSchemaUid;
+        if (re) {
+          const ke = Pt(se, hn, c) ?? Ut(
+            se,
+            g,
+            fn,
+            c
+          );
+          ke && (U[M.localId] = ke, w[b] = { ...w[b], seedUid: ke });
+        }
+      }
+      for (const b of w) {
+        const M = b?.localId, X = b?.seedUid;
+        M && X && j(X) !== $ && (U[M] = j(X));
+      }
+      S = (await mt(structuredClone(f), U)).map(
+        (b) => Ye({
+          ...b,
+          seedUid: U[b.localId] ?? b.seedUid
+        })
+      );
+    } else {
+      const w = f.map((re) => Ye(re)), U = new Map(w.map((re) => [re?.localId, re]));
+      Tt(w, U);
+      const F = Array.isArray(y) ? w : [w[0]], b = {
+        ...bt({
+          contract: m,
+          requests: F
+        }),
+        gas: 5000000n
+      }, M = await N({
+        account: A,
+        transaction: await Promise.resolve(b)
+      }), X = await k({
+        client: R(),
+        chain: v,
+        transactionHash: M.transactionHash
+      });
+      if (!X)
+        throw new Error("Failed to send transaction");
+      const ge = w[0], J = ge?.seedUid, Be = J === $ || !J, Fe = ge?.listOfAttestations?.length ?? 0, Ne = ge?.seedSchemaUid, se = Be ? Pt(X, Ne, c) ?? Ut(
+        X,
+        g,
+        Fe,
+        c
+      ) : void 0;
+      S = se && w.length > 0 ? [{ ...w[0], seedUid: se }, ...w.slice(1)] : w;
+    }
+    rn(o, S);
+    const E = o, D = S.find((w) => w?.localId === o.seedLocalId)?.seedUid;
+    return D && D !== $ && await on(E, n), ws("requestData", y), dn(e), { easPayload: y };
+  }
+), Dt = K("seedProtocol:services:publish:verifyAttestations"), As = "0x" + "0".repeat(64), Pe = 64, xt = (e) => e == null ? "0x" + "0".repeat(Pe) : typeof e == "string" ? "0x" + (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0").padStart(Pe, "0").slice(-Pe) : "0x" + "0".repeat(Pe), vs = 5e3, Je = 6;
+async function Ss({
+  normalizedRequests: e,
+  item: t
+}) {
+  const n = t.seedLocalId;
+  for (const a of e) {
+    if (a.listOfAttestations.length === 0 || a.versionUid === As) continue;
+    const s = a.listOfAttestations.map(
+      (d) => xt(d.schema).toLowerCase()
+    );
+    let r = [], o;
+    for (let d = 1; d <= Je; d++)
+      try {
+        d > 1 && await new Promise((p) => setTimeout(p, vs)), r = await Rn({
+          versionUids: [a.versionUid]
+        });
+        break;
+      } catch (p) {
+        if (o = p, Dt("verifyAttestations attempt %d failed:", d, p), d === Je)
+          throw Dt("verifyAttestations: giving up after %d attempts", Je), o;
+      }
+    const i = r.map((d) => d.schemaId ? xt(d.schemaId).toLowerCase() : "").filter(Boolean), c = new Set(i);
+    if (s.filter((d) => !c.has(d)).length > 0)
+      throw new Yt(
+        `Publish verification failed: Seed and Version attestations were created, but property/metadata attestations are missing or incomplete. Expected ${s.length} property attestations for schema(s) ${s.join(", ")}; found ${i.length}. Use PublishManager.retryAttestations('${n}') to retry.`,
+        n,
+        s,
+        i,
+        "METADATA_PROPERTIES_MISSING"
+      );
+  }
+}
+const be = K("seedProtocol:services:publish:createAttestationsDirectToEas"), le = 64, z = (e) => {
+  if (e == null) return "0x" + "0".repeat(le);
+  if (typeof e == "string")
+    return "0x" + (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0").padStart(le, "0").slice(-le);
+  if (e instanceof Uint8Array || typeof ArrayBuffer < "u" && e instanceof ArrayBuffer) {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    return "0x" + Array.from(t).map((a) => a.toString(16).padStart(2, "0")).join("").padStart(le, "0").slice(-le);
+  }
+  return "0x" + "0".repeat(le);
+}, Es = (e) => {
+  if (e == null || typeof e == "string" && (e === "" || e === "0x")) return "0x";
+  if (typeof e == "string") {
+    const n = (e.startsWith("0x") ? e.slice(2) : e).replace(/[^0-9a-fA-F]/g, "0");
+    return "0x" + (n.length % 2 === 1 ? "0" + n : n);
+  }
+  if (e instanceof Uint8Array || typeof ArrayBuffer < "u" && e instanceof ArrayBuffer) {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
+    return "0x" + Array.from(t).map((n) => n.toString(16).padStart(2, "0")).join("");
+  }
+  return "0x";
+}, Is = async (e) => {
+  let t;
+  try {
+    t = await ae.find({ seedLocalId: e });
+  } catch {
+  }
+  return t || new Promise((n) => {
+    const a = setInterval(() => {
+      try {
+        ae.find({ seedLocalId: e }).then((s) => {
+          s && (clearInterval(a), n(s));
+        });
+      } catch {
+      }
+    }, 200);
+  });
+}, Ps = he(
+  async ({ input: { context: e, event: t } }) => {
+    const { address: n, account: a } = e, s = e.arweaveTransactions ?? [], r = e.publishUploads ?? [];
+    let { item: o } = e;
+    if (!n || typeof n != "string" || !n.trim())
+      throw new Error("No wallet address for publish. Connect a wallet and try again.");
+    if (!a)
+      throw new Error("Wallet session is missing. Reconnect your wallet and retry the publish.");
+    if (!o?.seedLocalId)
+      throw new Error(
+        "Attestation recovery failed: Item data is missing. Delete this publish record and try a full publish from the beginning."
+      );
+    typeof o.getPublishUploads != "function" && (o = await Is(o.seedLocalId));
+    const c = s.length, u = r.length;
+    if (c !== u)
+      throw new Error(
+        "Attestation recovery failed: Arweave transaction data is missing or incomplete. Delete this publish record and try a full publish from the beginning."
+      );
+    await Oe(o, a, R(), v);
+    const d = s.map(
+      (g, I) => {
+        const E = g.transaction?.id;
+        if (!E || typeof E != "string")
+          throw new Error(
+            "Attestation recovery failed: Arweave transaction data did not survive restore. Delete this publish record and try a full publish from the beginning."
+          );
+        const W = r[I];
+        if (!W) throw new Error("Publish upload index mismatch");
+        return { ...W, txId: E };
+      }
+    );
+    await cn(d.map((g) => g.txId));
+    const p = await o.getPublishPayload(d, { publishMode: e.publishMode ?? "patch" }), m = (Array.isArray(p) ? p : [p]).map((g) => {
+      const I = (g?.listOfAttestations ?? []).map((E) => {
+        const W = Array.isArray(E?.data) ? E.data : [];
+        return {
+          schema: z(E?.schema),
+          data: W.map((D) => ({
+            ...D,
+            refUID: z(D?.refUID),
+            data: Es(D?.data)
+          }))
+        };
+      }), S = (g?.propertiesToUpdate ?? []).map((E) => ({
+        ...E,
+        propertySchemaUid: z(E?.propertySchemaUid)
+      }));
+      return {
+        ...g,
+        seedUid: z(g?.seedUid),
+        seedSchemaUid: z(g?.seedSchemaUid),
+        versionUid: z(g?.versionUid),
+        versionSchemaUid: z(g?.versionSchemaUid),
+        listOfAttestations: I,
+        propertiesToUpdate: S
+      };
+    }), h = new Map(m.map((g) => [g.localId, g])), y = {
+      recipient: Qe,
+      expirationTime: BigInt(0),
+      revocable: !0,
+      refUID: q,
+      data: q,
+      value: BigInt(0)
+    };
+    for (const g of m)
+      for (const I of g.propertiesToUpdate ?? []) {
+        const S = I.publishLocalId, E = z(I.propertySchemaUid);
+        if (!S || !E) continue;
+        const W = h.get(S);
+        if (!W?.listOfAttestations) continue;
+        const D = W.listOfAttestations.find(
+          (w) => z(w?.schema)?.toLowerCase() === E?.toLowerCase()
+        );
+        D && (!Array.isArray(D.data) || D.data.length === 0) && (D.data = [{ ...y, refUID: q }]);
+      }
+    const f = R();
+    for (let g = 0; g < m.length; g++) {
+      const I = m[g];
+      let S = I.seedUid, E = I.versionUid;
+      if (S === q) {
+        const D = yt(f, v, {
+          schema: I.seedSchemaUid,
+          data: {
+            refUID: q,
+            data: We(I.seedSchemaUid),
+            revocable: I.seedIsRevocable
+          }
+        }), w = await N({ account: a, transaction: D }), U = await k({
+          client: f,
+          chain: v,
+          transactionHash: w.transactionHash
+        });
+        if (!U) throw new Error("Failed to create Seed attestation");
+        const { easContractAddress: F } = C(), b = gt(U, F);
+        if (!b || b === q)
+          throw new Error("Failed to get Seed UID from attestation receipt");
+        S = b, I.seedUid = b, be("created Seed attestation", S);
+      }
+      if (S !== q && E === q) {
+        const D = yt(f, v, {
+          schema: I.versionSchemaUid,
+          data: {
+            refUID: S,
+            data: We(I.versionSchemaUid),
+            revocable: !0
+          }
+        }), w = await N({ account: a, transaction: D }), U = await k({
+          client: f,
+          chain: v,
+          transactionHash: w.transactionHash
+        });
+        if (!U) throw new Error("Failed to create Version attestation");
+        const { easContractAddress: F } = C(), b = gt(U, F);
+        if (!b || b === q)
+          throw new Error("Failed to get Version UID from attestation receipt");
+        E = b, I.versionUid = b, await _n({
+          seedLocalId: I.localId,
+          versionUid: b,
+          publisher: n
+        }), be("created Version attestation", E);
+      }
+      for (const D of I.listOfAttestations)
+        for (const w of D.data)
+          w.refUID = E;
+      for (const D of I.propertiesToUpdate ?? []) {
+        const w = h.get(D.publishLocalId);
+        if (!w?.listOfAttestations) continue;
+        const U = z(D.propertySchemaUid), F = w.listOfAttestations.find(
+          (b) => z(b?.schema)?.toLowerCase() === U?.toLowerCase()
+        );
+        F?.data?.[0] && (F.data[0].data = We(S));
+      }
+      const W = I.listOfAttestations.map((D) => ({
+        schema: D.schema,
+        data: D.data.map((w) => ({
+          recipient: w.recipient ?? Qe,
+          expirationTime: w.expirationTime ?? 0n,
+          revocable: w.revocable ?? !0,
+          refUID: w.refUID ?? q,
+          data: w.data ?? "0x",
+          value: w.value ?? 0n
+        }))
+      }));
+      if (W.length > 0) {
+        const D = ya(f, v, W), w = await N({ account: a, transaction: D });
+        if (!await k({
+          client: f,
+          chain: v,
+          transactionHash: w.transactionHash
+        })) throw new Error("Failed to create property attestations");
+        be("created property attestations for request", g);
+      }
+    }
+    rn(o, m);
+    const A = o;
+    m[0]?.seedUid && m[0].seedUid !== q && await on(A, n);
+    try {
+      await Ss({ normalizedRequests: m, item: o });
+    } catch (g) {
+      throw g instanceof Yt || be("verifyAttestations failed (non-verification error):", g), g;
+    }
+    return be("direct EAS publish complete"), dn(e), { easPayload: p };
+  }
+), Us = async (e) => {
+  let t;
+  try {
+    t = await ae.find({ seedLocalId: e });
+  } catch {
+  }
+  return t || new Promise((n) => {
+    const a = setInterval(() => {
+      ae.find({ seedLocalId: e }).then((s) => {
+        s && (clearInterval(a), n(s));
+      }).catch(() => {
+      });
+    }, 200);
+  });
+};
+async function Ts(e) {
+  const n = typeof e.getPublishUploads == "function" ? e : await Us(e.seedLocalId);
+  return await Ln(n);
+}
+const ue = /* @__PURE__ */ new Set(), Ds = ye(({ sendBack: e, input: { context: t } }) => {
+  const { item: n, account: a, publishMode: s } = t;
+  return (async () => {
+    if (!await Ot(n)) {
+      e({ type: "notOwner" });
+      return;
+    }
+    if (ue.has(n.seedLocalId)) {
+      e({
+        type: "redundantPublishProcess"
+      });
+      return;
+    }
+    ue.add(n.seedLocalId);
+    try {
+      a && await Oe(n, a, R(), v);
+      const i = await Mn(n, [], {
+        publishMode: s ?? "patch"
+      });
+      if (!i.isValid) {
+        ue.delete(n.seedLocalId), e({ type: "validationFailed", errors: i.errors });
+        return;
+      }
+      if (await Ts(n)) {
+        const u = C().useArweaveBundler;
+        e({ type: u ? "validPublishProcessBundler" : "validPublishProcess" });
+      } else
+        e({ type: "skipArweave" });
+    } catch (i) {
+      ue.delete(n.seedLocalId), console.error("[checking] itemNeedsArweaveUpload failed", i), e({ type: "skipArweave" });
+    }
+  })().catch(() => {
+    ue.delete(n.seedLocalId), e({ type: "validPublishProcess" });
+  }), () => {
+    ue.delete(n.seedLocalId);
+  };
+}), {
+  SUCCESS: ze,
+  FAILURE: Ze
+} = L;
+function ee(e) {
+  const t = e;
+  return t.error ?? t.data;
+}
+const ln = Ht({
+  types: {
+    context: {},
+    input: {}
+  },
+  actors: {
+    createArweaveTransactions: Fa,
+    createArweaveDataItems: za,
+    sendReimbursementRequest: ts,
+    pollForConfirmation: ns,
+    uploadData: ss,
+    uploadViaBundler: rs,
+    createAttestations: bs,
+    createAttestationsDirectToEas: Ps,
+    checking: Ds
+  },
+  actions: {
+    /** Log error; error/errorStep are assigned per transition. Supports both event.error (custom events) and event.data (XState fromPromise invoke errors). */
+    handleError: ({ event: e }) => {
+      const t = ee(e);
+      t != null ? console.error(t) : console.error("Unknown error (full event):", e);
+    },
+    assignErrorCreatingArweaveTransactions: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "creatingArweaveTransactions"
+    }),
+    assignErrorCreatingArweaveDataItems: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "creatingArweaveDataItems"
+    }),
+    assignErrorSendingReimbursementRequest: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "sendingReimbursementRequest"
+    }),
+    assignErrorPollingForConfirmation: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "pollingForConfirmation"
+    }),
+    assignErrorUploadingData: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "uploadingData"
+    }),
+    assignErrorUploadingViaBundler: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "uploadingViaBundler"
+    }),
+    assignErrorCreatingAttestations: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "creatingAttestations"
+    }),
+    assignErrorCreatingAttestationsDirectToEas: T({
+      error: ({ event: e }) => ee(e),
+      errorStep: () => "creatingAttestationsDirectToEas"
+    }),
+    assignAccountFromRetry: T({
+      account: ({ event: e }) => e.account
+    }),
+    assignErrorNotOwner: T({
+      error: () => new Error("Item is read-only: you do not own this item. Only the publisher can publish."),
+      errorStep: () => "checking"
+    }),
+    assignErrorValidationFailed: T({
+      error: ({ event: e }) => {
+        const n = e.errors ?? [], a = n.length > 0 ? `Validation failed (${n.length} error${n.length === 1 ? "" : "s"}):
+${n.map((r) => r.message).join(`
+`)}` : "Validation failed", s = new Error(a);
+        return s.validationErrors = n, s;
+      },
+      errorStep: () => "checking"
+    })
+  }
+}).createMachine({
+  id: "publish",
+  initial: "checking",
+  context: ({ input: e }) => e,
+  states: {
+    checking: {
+      on: {
+        notOwner: {
+          target: Ze,
+          actions: ["assignErrorNotOwner", "handleError"]
+        },
+        validationFailed: {
+          target: Ze,
+          actions: ["assignErrorValidationFailed", "handleError"]
+        },
+        redundantPublishProcess: {
+          target: "stopping"
+        },
+        validPublishProcess: {
+          target: "creatingArweaveTransactions"
+        },
+        validPublishProcessBundler: {
+          target: "creatingArweaveDataItems"
+        },
+        skipArweave: [
+          {
+            guard: () => C().useDirectEas,
+            target: "creatingAttestationsDirectToEas",
+            actions: T({
+              arweaveTransactions: () => [],
+              publishUploads: () => []
+            })
+          },
+          {
+            guard: () => !C().useDirectEas,
+            target: "creatingAttestations",
+            actions: T({
+              arweaveTransactions: () => [],
+              publishUploads: () => []
+            })
+          }
+        ]
+      },
+      invoke: {
+        src: "checking",
+        input: ({ context: e }) => ({ context: e })
+      }
+    },
+    creatingArweaveTransactions: {
+      invoke: {
+        src: "createArweaveTransactions",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: "sendingReimbursementRequest",
+          actions: T({
+            arweaveTransactions: ({ event: e }) => e.output.arweaveTransactions,
+            publishUploads: ({ event: e }) => e.output.publishUploads
+          })
+        },
+        onError: {
+          target: "failure",
+          actions: ["assignErrorCreatingArweaveTransactions", "handleError"]
+        }
+      }
+    },
+    creatingArweaveDataItems: {
+      invoke: {
+        src: "createArweaveDataItems",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: "uploadingViaBundler",
+          actions: T({
+            arweaveTransactions: ({ event: e }) => e.output.arweaveTransactions,
+            publishUploads: ({ event: e }) => e.output.publishUploads,
+            arweaveUploadData: ({ event: e }) => e.output.arweaveUploadData,
+            signedDataItems: ({ event: e }) => e.output.signedDataItems
+          })
+        },
+        onError: {
+          target: "failure",
+          actions: ["assignErrorCreatingArweaveDataItems", "handleError"]
+        }
+      }
+    },
+    sendingReimbursementRequest: {
+      invoke: {
+        src: "sendReimbursementRequest",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: "pollingForConfirmation",
+          actions: T({
+            requestResponse: ({ event: e }) => e.output,
+            reimbursementTransactionId: ({ event: e }) => e.output.transactionId
+          })
+        },
+        onError: {
+          target: "failure",
+          actions: ["assignErrorSendingReimbursementRequest", "handleError"]
+        }
+      }
+    },
+    pollingForConfirmation: {
+      invoke: {
+        src: "pollForConfirmation",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: "uploadingData",
+          actions: T({
+            reimbursementConfirmed: !0
+          })
+        },
+        onError: {
+          target: "failure",
+          actions: ["assignErrorPollingForConfirmation", "handleError"]
+        }
+      }
+    },
+    uploadingViaBundler: {
+      on: {
+        uploadComplete: [
+          {
+            guard: () => C().useDirectEas,
+            target: "creatingAttestationsDirectToEas",
+            actions: T({
+              completionPercentage: 100
+            })
+          },
+          {
+            guard: () => !C().useDirectEas,
+            target: "creatingAttestations",
+            actions: T({
+              completionPercentage: 100
+            })
+          }
+        ],
+        uploadError: {
+          target: "failure",
+          actions: ["assignErrorUploadingViaBundler", "handleError"]
+        }
+      },
+      invoke: {
+        src: "uploadViaBundler",
+        input: ({ context: e }) => ({ context: e })
+      }
+    },
+    uploadingData: {
+      on: {
+        updatePercentage: {
+          actions: T({
+            completionPercentage: ({ event: e }) => e.completionPercentage,
+            uploaderState: ({ event: e }) => e.uploaderState,
+            currentTransactionIndex: ({ event: e }) => e.currentTransactionIndex
+          })
+        },
+        uploadComplete: [
+          {
+            guard: () => C().useDirectEas,
+            target: "creatingAttestationsDirectToEas",
+            actions: T({
+              completionPercentage: 100
+            })
+          },
+          {
+            guard: () => !C().useDirectEas,
+            target: "creatingAttestations",
+            actions: T({
+              completionPercentage: 100
+            })
+          }
+        ],
+        uploadError: {
+          target: "failure",
+          actions: ["assignErrorUploadingData", "handleError"]
+        }
+      },
+      invoke: {
+        src: "uploadData",
+        input: ({ context: e }) => ({ context: e })
+      }
+    },
+    creatingAttestations: {
+      invoke: {
+        src: "createAttestations",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: ze,
+          actions: T({
+            easPayload: ({ event: e }) => e.output?.easPayload
+          })
+        },
+        onError: {
+          target: "attestationFailureRecoverable",
+          actions: ["assignErrorCreatingAttestations", "handleError"]
+        }
+      }
+    },
+    attestationFailureRecoverable: {
+      on: {
+        retry: {
+          target: "creatingAttestations",
+          actions: ["assignAccountFromRetry"]
+        }
+      }
+    },
+    creatingAttestationsDirectToEas: {
+      invoke: {
+        src: "createAttestationsDirectToEas",
+        input: ({ context: e, event: t }) => ({ context: e, event: t }),
+        onDone: {
+          target: ze,
+          actions: T({
+            easPayload: ({ event: e }) => e.output?.easPayload
+          })
+        },
+        onError: {
+          target: "attestationFailureRecoverableDirectToEas",
+          actions: ["assignErrorCreatingAttestationsDirectToEas", "handleError"]
+        }
+      }
+    },
+    attestationFailureRecoverableDirectToEas: {
+      on: {
+        retry: {
+          target: "creatingAttestationsDirectToEas",
+          actions: ["assignAccountFromRetry"]
+        }
+      }
+    },
+    stopping: {
+      entry: ({ context: e }) => {
+        console.log(`Actor for ${e.item?.seedLocalId} stopped`);
+      },
+      type: "final"
+    },
+    [ze]: {
+      type: "final"
+    },
+    [Ze]: {
+      type: "final"
+    }
+  }
+}), xs = T(({ context: e, event: t }) => {
+  const n = t, a = n.publishProcesses ?? /* @__PURE__ */ new Map(), s = n.subscriptions ?? /* @__PURE__ */ new Map();
+  return {
+    publishProcesses: new Map(a),
+    subscriptions: new Map(
+      s
+    )
+  };
+});
+let un = null;
+function Cs(e) {
+  un = e;
+}
+function Rs() {
+  return un;
+}
+const Ct = K("seedProtocol:services:PublishManager:actors:subscribe");
+function Rt(e) {
+  const t = e.value;
+  return typeof t == "string" ? t : t && typeof t == "object" ? Object.keys(t)[0] ?? "" : "";
+}
+function Ke(e) {
+  return ia.includes(e);
+}
+const pn = ye(
+  ({ receive: e, input: { publishProcess: t, seedLocalId: n } }) => {
+    const a = Rs();
+    let s = null;
+    const r = () => {
+      s != null && (clearInterval(s), s = null);
+    }, o = (c) => {
+      const u = Rt(c);
+      Ke(u) && s == null && a ? s = setInterval(() => {
+        try {
+          const d = t.getSnapshot();
+          if (d.status === "done") {
+            r();
+            return;
+          }
+          const p = Rt(d);
+          if (!Ke(p)) {
+            r();
+            return;
+          }
+        } catch {
+          return;
+        }
+        a?.savePublish(n, t);
+      }, ca) : Ke(u) || r();
+    }, i = t.subscribe(async (c) => {
+      Ct("Publish state:", c.value), a && (c.status === "done" ? (r(), a.savePublish(n, t, { triggerPublishDone: !0 })) : (a.savePublish(n, t), o(c)));
+    });
+    e(({ type: c }) => {
+      c === "UNSUBSCRIBE" && (Ct("Received UNSUBSCRIBE event"), r(), i.unsubscribe(), a?.removeSubscription(n));
+    });
+  }
+), _s = Le(({ event: e, enqueue: t }) => {
+  const n = e, { item: a, address: s, account: r, options: o } = n;
+  if (!(s != null && typeof s == "string" && s.trim().length > 0)) {
+    console.warn("[createPublish] No valid wallet address; skipping spawn.");
+    return;
+  }
+  t.assign(({ context: c, spawn: u }) => {
+    const { publishProcesses: d } = c;
+    if (d && d.has(a.seedLocalId))
+      return console.warn(`Publish process with seedLocalId "${a.seedLocalId}" already exists.`), c;
+    const p = typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : `run_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`, l = u(ln, {
+      input: {
+        item: a,
+        address: s,
+        account: r,
+        modelName: a.modelName,
+        schemaId: a.schemaUid,
+        signDataItems: o?.signDataItems,
+        dataItemSigner: o?.dataItemSigner,
+        signArweaveTransactions: o?.signArweaveTransactions,
+        arweaveJwk: o?.arweaveJwk,
+        publishMode: o?.publishMode ?? "patch",
+        publishRunId: p
+      }
+    });
+    return d.set(a.seedLocalId, l), {
+      publishProcesses: new Map(d)
+    };
+  }), t.assign(({ context: c, spawn: u }) => {
+    const { subscriptions: d, publishProcesses: p } = c, l = p.get(a.seedLocalId);
+    if (!l)
+      return console.warn(`Publish process with seedLocalId "${a.seedLocalId}" does not exist.`), c;
+    if (d && d.has(a.seedLocalId))
+      return console.warn(`Subscription with seedLocalId "${a.seedLocalId}" already exists.`), c;
+    const m = u(pn, {
+      input: { publishProcess: l, seedLocalId: a.seedLocalId }
+    });
+    return d.set(a.seedLocalId, m), {
+      subscriptions: new Map(d)
+    };
+  });
+}), Ls = ({
+  context: e,
+  event: t
+}) => {
+  const n = t, { seedLocalId: a, account: s } = n, r = e.publishProcesses.get(a);
+  if (!r) {
+    console.warn(`Publish process with seedLocalId "${a}" does not exist.`);
+    return;
+  }
+  r.send({ type: "retry", account: s });
+}, Ms = Le(({ context: e, event: t, enqueue: n }) => {
+  const { publishProcesses: a, subscriptions: s } = e, { seedLocalId: r } = t, o = a.get(r);
+  if (!o) {
+    console.warn(`Publish process with seedLocalId "${r}" does not exist.`);
+    return;
+  }
+  n.stopChild(o);
+  const i = s.get(r);
+  i && n.stopChild(i);
+  const c = new Map(a);
+  c.delete(r);
+  const u = new Map(s);
+  u.delete(r), n.assign({
+    publishProcesses: c,
+    subscriptions: u
+  });
+}), Os = K("seedProtocol:PublishManager:index"), Bs = Le(({ context: e, enqueue: t }) => {
+  Os("Stopping all actors..."), e.publishProcesses.forEach((n) => {
+    t.stopChild(n);
+  }), e.subscriptions.forEach((n) => {
+    t.stopChild(n);
+  }), t.assign({
+    publishProcesses: /* @__PURE__ */ new Map(),
+    subscriptions: /* @__PURE__ */ new Map()
+  });
+}), Fs = Le(({ context: e, event: t, enqueue: n }) => {
+  const { seedLocalId: a } = t, s = e.publishProcesses.get(a);
+  if (!s) {
+    console.warn(`Publish process with seedLocalId "${a}" does not exist.`);
+    return;
+  }
+  n.stopChild(s);
+  const r = e.subscriptions.get(a);
+  r && n.stopChild(r);
+  const o = new Map(e.publishProcesses);
+  o.delete(a);
+  const i = new Map(e.subscriptions);
+  i.delete(a), n.assign({
+    publishProcesses: o,
+    subscriptions: i
+  });
+}), Ns = T(({ context: e, event: t }) => {
+  const { subscriptions: n } = e, { seedLocalId: a, newSubscription: s } = t;
+  return s && n.set(a, s), {
+    subscriptions: new Map(n)
+  };
+}), Ue = K("seedProtocol:services:PublishManager:actors:savePublish"), _t = /* @__PURE__ */ new Map();
+function ks(e, t) {
+  const a = (_t.get(e) ?? Promise.resolve()).then(t);
+  return _t.set(e, a.catch(() => {
+  })), a;
+}
+function Hs(e) {
+  return e.status === "done" ? e.value === "success" ? "completed" : e.value === "failure" ? "failed" : "completed" : "in_progress";
+}
+const $s = 500, Te = 2e3;
+function Vs(e) {
+  return JSON.stringify(e, (t, n) => typeof n == "bigint" ? n.toString() : n);
+}
+function Lt(e) {
+  if (e == null || typeof e != "object") return;
+  const t = e, n = t.snapshot, s = (t.context ?? n?.context)?.publishRunId;
+  return typeof s == "string" && s.length > 0 ? s : void 0;
+}
+function Ws(e, t) {
+  if (!e?.error) return {};
+  if (t !== "failed" && t !== "in_progress") return {};
+  const n = e.error, a = n != null ? (n instanceof Error ? n.message : String(n)).slice(0, $s) : void 0, s = e.errorStep;
+  let r;
+  if (n instanceof Error && n.stack)
+    r = n.stack.slice(0, Te);
+  else if (n != null && typeof n == "object")
+    try {
+      r = JSON.stringify(n).slice(0, Te);
+    } catch {
+      r = String(n).slice(0, Te);
+    }
+  else n != null && (r = String(n).slice(0, Te));
+  return { errorMessage: a ?? void 0, errorStep: s, errorDetails: r };
+}
+const qs = ye(({ sendBack: e, input: { persistedSnapshot: t, seedLocalId: n, triggerPublishDone: a } }) => {
+  Ue("savePublish seedLocalId", n);
+  const s = t;
+  ks(n, async () => {
+    const o = B.getAppDb();
+    if (!o) {
+      Ue("savePublish: DB not ready, skipping"), e({ type: "SAVE_PUBLISH_DONE", seedLocalId: n, triggerPublishDone: a });
+      return;
+    }
+    const i = await o.select().from(P).where(ea(Z(P.seedLocalId, n), Z(P.status, "in_progress"))).orderBy(fe(P.updatedAt)).limit(1), c = typeof t == "string" ? t : Vs(t), u = Hs(s), d = Date.now(), p = Ws(s.context, u);
+    if (i.length > 0) {
+      const l = i[0];
+      await o.update(P).set({
+        persistedSnapshot: c,
+        status: u,
+        updatedAt: d,
+        ...s.status === "done" && u !== "in_progress" ? { completedAt: d } : {},
+        ...p
+      }).where(Z(P.id, l.id));
+    } else {
+      const l = Lt(s);
+      if (l != null && u === "in_progress" && s.status !== "done") {
+        const A = (await o.select().from(P).where(Z(P.seedLocalId, n)).orderBy(fe(P.startedAt)).limit(1))[0];
+        if (A && (A.status === "completed" || A.status === "failed"))
+          try {
+            const g = JSON.parse(A.persistedSnapshot);
+            if (Lt(g) === l) {
+              Ue(
+                "savePublish: skip stale insert — same publishRunId as latest terminal row",
+                n,
+                l
+              );
+              return;
+            }
+          } catch {
+          }
+      }
+      const m = s.context?.item, h = s.context?.modelName ?? m?.modelName ?? "", y = s.context?.schemaId ?? m?.schemaId;
+      await o.insert(P).values({
+        seedLocalId: n,
+        modelName: h,
+        schemaId: y ?? null,
+        status: u,
+        startedAt: d,
+        persistedSnapshot: c,
+        createdAt: d,
+        updatedAt: d,
+        ...p
+      });
+    }
+  }).then(() => {
+    e({ type: "SAVE_PUBLISH_DONE", seedLocalId: n, triggerPublishDone: a });
+  }).catch((o) => {
+    Ue("savePublish error", o), e({ type: "SAVE_PUBLISH_DONE", seedLocalId: n, triggerPublishDone: a });
+  });
+});
+function js(e) {
+  try {
+    return e.getPersistedSnapshot?.() ?? e.getSnapshot();
+  } catch {
+    const t = e.getSnapshot(), n = t.context;
+    if (!n?.item) return t;
+    const a = n.item;
+    return {
+      ...t,
+      context: {
+        ...n,
+        item: {
+          seedLocalId: a.seedLocalId,
+          modelName: a.modelName,
+          schemaId: a.schemaId
+        }
+      }
+    };
+  }
+}
+const Gs = T(({ context: e, event: t, spawn: n }) => {
+  const { publishProcesses: a } = e, { seedLocalId: s, publishProcess: r, triggerPublishDone: o } = t;
+  if (!r)
+    return e;
+  const i = new Map(a);
+  i.set(s, r);
+  const c = js(r);
+  return n(qs, {
+    id: `savePublish_${s}_${Date.now()}`,
+    input: { persistedSnapshot: c, seedLocalId: s, triggerPublishDone: o }
+  }), { publishProcesses: i };
+}), Ys = T(({ context: e, event: t }) => {
+  const { publishProcesses: n, subscriptions: a } = e, s = t.seedLocalId, r = a.get(s);
+  r && r.send({ type: "UNSUBSCRIBE" });
+  const o = new Map(n);
+  o.delete(s);
+  const i = new Map(a);
+  return i.delete(s), {
+    publishProcesses: o,
+    subscriptions: i
+  };
+}), Js = T(({ context: e, event: t }) => {
+  const { subscriptions: n } = e, a = t.seedLocalId, s = new Map(n);
+  return s.delete(a), {
+    subscriptions: s
+  };
+}), zs = 6e4, Zs = 2e3;
+async function Ks(e) {
+  const t = Date.now() + e;
+  for (; Date.now() < t; ) {
+    if (B.PlatformClass && B.getAppDb()) return !0;
+    await new Promise((n) => setTimeout(n, Zs));
+  }
+  return !1;
+}
+function Qs(e) {
+  const t = e.value;
+  return typeof t == "string" ? t : t && typeof t == "object" ? Object.keys(t)[0] ?? "" : "";
+}
+function Xs(e) {
+  const t = Qs(e);
+  if (t === "pollingForConfirmation" && (!e.context?.reimbursementTransactionId || !e.context?.requestResponse))
+    return !1;
+  if (t === "uploadingData") {
+    const n = e.context?.arweaveTransactions, a = e.context?.publishUploads;
+    if (!Array.isArray(n) || n.length === 0 || !Array.isArray(a)) return !1;
+  }
+  return !0;
+}
+const er = ye(
+  ({ sendBack: e, input: { context: t } }) => {
+    (async () => {
+      const a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+      if (!await Ks(zs))
+        return e({ type: "RESTORE_FROM_DB_DONE", publishProcesses: a, subscriptions: s }), { newPublishProcesses: a, newSubscriptions: s };
+      const o = B.getAppDb();
+      if (!o)
+        return e({ type: "RESTORE_FROM_DB_DONE", publishProcesses: a, subscriptions: s }), { newPublishProcesses: a, newSubscriptions: s };
+      const i = await o.select().from(P).where(Z(P.status, "in_progress")), c = /* @__PURE__ */ new Map(), u = [...i].sort(
+        (p, l) => (l.updatedAt ?? l.createdAt ?? 0) - (p.updatedAt ?? p.createdAt ?? 0)
+      );
+      for (const p of u)
+        c.has(p.seedLocalId) || c.set(p.seedLocalId, p);
+      const d = Array.from(c.values());
+      for (const p of d) {
+        let l;
+        try {
+          l = JSON.parse(p.persistedSnapshot);
+        } catch {
+          continue;
+        }
+        if (l.status === "done") continue;
+        const m = l.context?.item?.seedLocalId ?? p.seedLocalId;
+        if (!m || !Xs(l)) continue;
+        l.context = l.context ?? {}, l.context.item = {
+          ...l.context.item,
+          seedLocalId: m,
+          modelName: l.context.item?.modelName ?? l.context.modelName ?? p.modelName ?? "",
+          schemaId: l.context.item?.schemaId ?? l.context.schemaId ?? p.schemaId ?? void 0
+        };
+        const h = Xe(ln, {
+          snapshot: l,
+          input: void 0
+        }), y = Xe(pn, {
+          input: {
+            publishProcess: h,
+            seedLocalId: m
+          }
+        });
+        a.set(m, h), s.set(m, y), h.start(), y.start();
+      }
+      return { newPublishProcesses: a, newSubscriptions: s };
+    })().then((a) => {
+      if (!a) return;
+      const { newPublishProcesses: s, newSubscriptions: r } = a;
+      e({
+        type: "RESTORE_FROM_DB_DONE",
+        publishProcesses: s,
+        subscriptions: r
+      });
+    });
+  }
+), mn = K("seedProtocol:PublishManager:index"), tr = Ht({
+  types: {
+    context: {},
+    input: {},
+    events: {}
+  },
+  actors: {
+    restoreFromDb: er
+  },
+  actions: {
+    assignRestoreFromDb: xs,
+    createPublish: _s,
+    addSubscription: Ns,
+    requestSavePublish: Gs,
+    publishDone: Ys,
+    removeSubscription: Js,
+    retryAttestations: Ls,
+    stopPublish: Ms,
+    stopAll: Bs,
+    query: Fs
+  }
+}).createMachine({
+  id: "publishManager",
+  initial: "restoreFromDb",
+  context: {
+    publishProcesses: /* @__PURE__ */ new Map(),
+    subscriptions: /* @__PURE__ */ new Map()
+  },
+  states: {
+    restoreFromDb: {
+      on: {
+        RESTORE_FROM_DB_DONE: {
+          target: "active",
+          actions: ["assignRestoreFromDb"]
+        }
+      },
+      invoke: {
+        src: "restoreFromDb",
+        input: ({ context: e }) => ({ context: e })
+      }
+    },
+    active: {
+      on: {
+        CREATE_PUBLISH: {
+          actions: ["createPublish"]
+        },
+        ADD_SUBSCRIPTION: {
+          actions: ["addSubscription"]
+        },
+        REQUEST_SAVE_PUBLISH: {
+          actions: ["requestSavePublish"]
+        },
+        SAVE_PUBLISH_DONE: [
+          {
+            guard: ({ event: e }) => e.triggerPublishDone === !0,
+            actions: ["publishDone"]
+          }
+        ],
+        PUBLISH_DONE: {
+          actions: ["publishDone"]
+        },
+        REMOVE_SUBSCRIPTION: {
+          actions: ["removeSubscription"]
+        },
+        RETRY_ATTESTATIONS: {
+          actions: ["retryAttestations"]
+        },
+        STOP_PUBLISH: {
+          actions: ["stopPublish"]
+        },
+        QUERY: {
+          actions: ["query"]
+        },
+        STOP_ALL: {
+          actions: ["stopAll"]
+        }
+      }
+    }
+  }
+}), O = Xe(tr, {
+  input: {
+    publishProcesses: /* @__PURE__ */ new Map(),
+    subscriptions: /* @__PURE__ */ new Map()
+  }
+});
+Cs({
+  savePublish: (e, t, n) => {
+    O.send({
+      type: "REQUEST_SAVE_PUBLISH",
+      seedLocalId: e,
+      publishProcess: t,
+      triggerPublishDone: n?.triggerPublishDone
+    });
+  },
+  onPublishDone: (e) => {
+    O.send({ type: "PUBLISH_DONE", seedLocalId: e });
+  },
+  removeSubscription: (e) => {
+    O.send({ type: "REMOVE_SUBSCRIPTION", seedLocalId: e });
+  }
+});
+const nr = O.subscribe((e) => {
+  mn("PublishManager snapshot:", e);
+});
+typeof document < "u" && (O.start(), window.addEventListener("load", () => {
+  mn("PublishManager started");
+}), window.addEventListener("beforeunload", () => {
+  nr.unsubscribe(), O.stop();
+}));
+const nt = {
+  getService: () => O,
+  createPublish: (e, t, n, a) => O.send({ type: "CREATE_PUBLISH", item: e, address: t, account: n, options: a }),
+  retryAttestations: (e, t) => O.send({ type: "RETRY_ATTESTATIONS", seedLocalId: e, account: t }),
+  stopPublish: (e) => O.send({ type: "STOP_PUBLISH", seedLocalId: e }),
+  query: (e) => O.send({ type: "QUERY", seedLocalId: e }),
+  stopAll: () => O.send({ type: "STOP_ALL" }),
+  getPublish: (e) => O.getSnapshot().context.publishProcesses.get(e),
+  savePublish: (e, t) => O.send({ type: "REQUEST_SAVE_PUBLISH", seedLocalId: e, publishProcess: t }),
+  addSubscription: (e, t) => O.send({ type: "ADD_SUBSCRIPTION", seedLocalId: e, newSubscription: t }),
+  removeSubscription: (e) => O.send({ type: "REMOVE_SUBSCRIPTION", seedLocalId: e })
+};
+function _o(e) {
+  return e === "creatingAttestationsDirectToEas" ? "creatingAttestations" : e;
+}
+function ar(e, t, n) {
+  return e != null ? n : t?.status === "completed" ? L.SUCCESS : t?.status === "failed" ? L.FAILURE : n;
+}
+function sr(e) {
+  if (e) {
+    if (e.status === "failed") return L.FAILURE;
+    if (e.status === "completed") return L.SUCCESS;
+    if (e.completedAt != null) {
+      try {
+        const t = JSON.parse(e.persistedSnapshot);
+        if (t.status === "done" && t.value === L.FAILURE)
+          return L.FAILURE;
+      } catch {
+      }
+      return L.SUCCESS;
+    }
+    try {
+      const t = JSON.parse(e.persistedSnapshot);
+      if (t.status === "done") {
+        if (t.value === L.SUCCESS) return L.SUCCESS;
+        if (t.value === L.FAILURE) return L.FAILURE;
+      }
+      if (typeof t.value == "string") return t.value;
+    } catch {
+      return;
+    }
+  }
+}
+function rr(e) {
+  return !e || e.status !== "done" ? !1 : e.value === L.SUCCESS || e.value === L.FAILURE;
+}
+function or(e) {
+  const t = nt.getService(), n = aa(t, (m) => m?.context?.publishProcesses?.get(e) ?? null), a = Ft(null);
+  te(() => {
+    a.current = null;
+  }, [e]);
+  const [s, r] = Ae(void 0), [o, i] = Ae(null), c = B.getAppDb(), d = ve(
+    e && c ? c.select().from(P).where(Z(P.seedLocalId, e)).orderBy(fe(P.startedAt)).limit(1) : null
+  )?.[0], p = d?.status, l = Nt(() => {
+    if (n != null)
+      return s;
+    if (o === "success" || o === "failure")
+      return o;
+    const m = sr(d);
+    return m === L.SUCCESS || m === L.FAILURE ? m : ar(
+      n,
+      p != null ? { status: p } : void 0,
+      s
+    );
+  }, [n, p, s, o, d]);
+  return te(() => {
+    i(null);
+  }, [e]), te(() => {
+    n == null && (p === "completed" ? i("success") : p === "failed" && i("failure"));
+  }, [p, n]), te(() => {
+    n != null && i(null);
+  }, [n]), te(() => {
+    if (!n) {
+      const y = a.current;
+      rr(y) ? (r(y.value), y.value === L.SUCCESS ? i("success") : y.value === L.FAILURE && i("failure")) : r(void 0);
+      return;
+    }
+    const m = n.getSnapshot();
+    a.current = { value: m?.value, status: m.status }, r(m?.value);
+    const h = n.subscribe((y) => {
+      a.current = { value: y?.value, status: y?.status }, r(y?.value);
+    });
+    return () => {
+      h.unsubscribe();
+    };
+  }, [n, e]), {
+    publishProcess: n ?? null,
+    value: l
+  };
+}
+function Lo(e) {
+  const [t, n] = Ae(!0);
+  return te(() => {
+    if (!e) {
+      n(!1);
+      return;
+    }
+    Ot(e).then(n).catch(() => n(!1));
+  }, [e?.seedLocalId]), t;
+}
+function ir(e) {
+  const t = B.getAppDb(), a = ve(
+    e && t ? t.select().from(De).where(Z(De.seedLocalId, e)).orderBy(fe(De.updatedAt)) : null
+  ) ?? [];
+  return Nt(() => {
+    const r = a.filter((i) => i.phase === "pending_l1").length, o = a.filter((i) => i.phase === "confirmed").length;
+    return {
+      hasPendingL1: r > 0,
+      pendingCount: r,
+      confirmedCount: o,
+      jobs: a
+    };
+  }, [a]);
+}
+function Mo(e) {
+  const { publishProcess: t, value: n } = or(e ?? ""), a = ir(e), s = B.getAppDb(), o = ve(
+    e && s ? s.select().from(P).where(Z(P.seedLocalId, e)).orderBy(fe(P.startedAt)).limit(1) : null
+  )?.[0], i = !!t || o?.status === "in_progress";
+  return {
+    latestRecord: o,
+    publishProcess: t,
+    isActive: i,
+    publishValue: n,
+    arweaveL1Pending: a.hasPendingL1,
+    arweaveL1Jobs: a.jobs,
+    arweaveL1Summary: a
+  };
+}
+function cr() {
+  const e = B.getAppDb();
+  return ve(
+    e ? e.select().from(P).orderBy(fe(P.startedAt)) : null
+  );
+}
+function Oo() {
+  const e = cr();
+  if (e !== void 0)
+    return e.filter((t) => t.status !== "in_progress").length;
+}
+function Bo(e) {
+  const t = B.getAppDb(), n = ve(
+    e != null && t ? t.select().from(P).where(Z(P.id, e)).limit(1) : null
+  ), a = n === void 0;
+  return { record: n && n.length > 0 ? n[0] : null, isLoading: a };
+}
+async function Fo() {
+  const e = B.getAppDb();
+  e && await e.delete(P).where(ta(P.status, ["in_progress"]));
+}
+async function No() {
+  const e = B.getAppDb();
+  e && await e.delete(P);
+}
+async function ko() {
+  const e = B.getAppDb();
+  e && await e.delete(On);
+}
+async function Ho(e) {
+  const t = B.getAppDb();
+  t && await t.delete(P).where(Z(P.seedLocalId, e));
+}
+async function $o(e) {
+  const t = B.getAppDb();
+  t && await t.delete(P).where(Z(P.id, e));
+}
+async function Vo(e) {
+  if (e.length === 0) return;
+  const t = B.getAppDb();
+  t && await t.delete(P).where(na(P.id, e));
+}
+function Wo(e) {
+  try {
+    return (JSON.parse(e.persistedSnapshot).context?.arweaveTransactions ?? []).map((a) => a.transaction?.id).filter((a) => typeof a == "string");
+  } catch {
+    return [];
+  }
+}
+function qo(e) {
+  try {
+    return JSON.parse(e.persistedSnapshot).context?.easPayload ?? void 0;
+  } catch {
+    return;
+  }
+}
+function jo(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (let n = 0; n < e.length; n++) {
+    const a = e[n]?.localId;
+    a != null && t.set(a, BigInt(n));
+  }
+  return e.map((n, a) => {
+    const s = (n.propertiesToUpdate ?? []).map((i) => {
+      const c = i.publishLocalId, u = c != null ? t.get(c) : void 0;
+      if (c != null && c !== "" && u === void 0)
+        throw new Error(
+          `publishLocalId "${c}" not found in payload (valid localIds: ${Array.from(t.keys()).join(", ")})`
+        );
+      const { publishLocalId: d, ...p } = i;
+      return {
+        ...p,
+        publishLocalIdIndex: u ?? BigInt(0)
+      };
+    }), { localId: r, ...o } = n;
+    return {
+      ...o,
+      localIdIndex: BigInt(a),
+      propertiesToUpdate: s
+    };
+  });
+}
+const dr = "A connected wallet is required for publishing with the modular executor. Connect your wallet and try again.";
+async function Go(e, t, n, a) {
+  const s = C(), r = await n();
+  if (!r || !r.trim())
+    return { outcome: "no_address" };
+  if (s.useModularExecutor) {
+    if (!t)
+      return {
+        outcome: "managed_not_ready",
+        error: new Q(dr, "MANAGED_ACCOUNT_UNAVAILABLE")
+      };
+    const i = await sn();
+    if (!i.ok)
+      return { outcome: "managed_not_ready", error: i.error };
+    const c = i.managedAddress, u = await ht(t ?? null);
+    return "needsDeploy" in u ? { outcome: "needs_deploy" } : (nt.createPublish(e, c, u.account, {
+      dataItemSigner: u.account,
+      ...a
+    }), { outcome: "started" });
+  }
+  const o = await ht(t ?? null);
+  return "address" in o ? (nt.createPublish(e, o.address, o.account, {
+    dataItemSigner: o.account,
+    ...a
+  }), { outcome: "started" }) : { outcome: "needs_deploy" };
+}
+export {
+  ua as $,
+  Yt as A,
+  _e as B,
+  Br as C,
+  Ga as D,
+  _o as E,
+  sr as F,
+  ar as G,
+  jo as H,
+  Go as I,
+  et as J,
+  Et as K,
+  cs as L,
+  Q as M,
+  sn as N,
+  R as O,
+  Fr as P,
+  xr as Q,
+  Cr as R,
+  Rr as S,
+  qt as T,
+  jt as U,
+  Re as V,
+  ht as W,
+  _r as X,
+  la as Y,
+  Lr as Z,
+  rt as _,
+  wt as a,
+  Me as a0,
+  ot as a1,
+  pa as a2,
+  Nr as a3,
+  kr as a4,
+  Hr as a5,
+  $r as a6,
+  La as a7,
+  Vr as a8,
+  Wr as a9,
+  yo as aA,
+  go as aB,
+  wo as aC,
+  bo as aD,
+  Ao as aE,
+  vo as aF,
+  So as aG,
+  Eo as aH,
+  Io as aI,
+  Po as aJ,
+  Uo as aK,
+  bt as aL,
+  To as aM,
+  Do as aN,
+  xo as aO,
+  Co as aP,
+  Ro as aQ,
+  qr as aa,
+  Ma as ab,
+  jr as ac,
+  Gr as ad,
+  Yr as ae,
+  Jr as af,
+  zr as ag,
+  Zr as ah,
+  Kr as ai,
+  Qr as aj,
+  Xr as ak,
+  eo as al,
+  to as am,
+  no as an,
+  ao,
+  so as ap,
+  ro as aq,
+  oo as ar,
+  io as as,
+  co as at,
+  lo as au,
+  uo as av,
+  po as aw,
+  mo as ax,
+  fo as ay,
+  ho as az,
+  Ea as b,
+  Mr as c,
+  Or as d,
+  Oe as e,
+  nt as f,
+  C as g,
+  or as h,
+  Gt as i,
+  Lo as j,
+  Mo as k,
+  cr as l,
+  Oo as m,
+  Bo as n,
+  Fo as o,
+  ln as p,
+  No as q,
+  ko as r,
+  Sa as s,
+  Ho as t,
+  Ia as u,
+  $o as v,
+  Vo as w,
+  Wo as x,
+  qo as y,
+  ir as z
+};
+//# sourceMappingURL=index-P7oBN4Yu.js.map