@seedprotocol/sdk 0.4.14 → 0.4.15

package/dist/getPublishPayload-CdfPTl8l.js

@@ -0,0 +1,875 @@
+import { w as getEasSchemaUidForModel, Z as ZERO_BYTES32, o as BaseDb, x as models, y as properties, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, z as versions, A as modelPropertiesToObject, b as ModelPropertyDataTypes, q as getCorrectId, C as parseListPropertyValueFromStorage, E as INTERNAL_PROPERTY_NAMES, G as defaultAttestationData, H as INTERNAL_DATA_TYPES, K as toSnakeCase$1, O as getEasSchemaUidForSchemaDefinition, Q as getEasSchemaForItemProperty } from './index-uPXtq2cf.js';
+import { toSnakeCase } from 'drizzle-orm/casing';
+import pluralize from 'pluralize';
+import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-CJWdYH9W.js';
+import { getPropertySchema } from './property-Dt0U3UXJ.js';
+import { upperFirst, camelCase } from 'lodash-es';
+import { eq, and, desc } from 'drizzle-orm';
+import debug from 'debug';
+import { ethers } from 'ethers';
+import 'reflect-metadata';
+import 'xstate';
+import 'drizzle-orm/sqlite-core';
+import 'nanoid';
+import 'nanoid-dictionary';
+import '@sinclair/typebox';
+import 'rxjs';
+import 'eventemitter3';
+import 'arweave';
+import 'js-sha3';
+
+// Dynamic import to break circular dependency with getItem -> BaseItem
+// import { getItem } from '@/db/read/getItem'
+debug('seedSdk:db:getPublishPayload');
+function addValidationError(ctx, message, field, code = 'publish_validation') {
+    ctx.errors.push({ field: field ?? '', message, code });
+}
+const getVersionUid = (item) => {
+    const latestVersion = item.latestVersionUid;
+    if (latestVersion && typeof latestVersion === 'object' && latestVersion.uid) {
+        return latestVersion.uid;
+    }
+    if (latestVersion && typeof latestVersion === 'string') {
+        return latestVersion;
+    }
+    return ZERO_BYTES32;
+};
+/**
+ * Resolve versionUid when item.latestVersionUid is empty but item has been published (has seedUid).
+ * Tries DB first, then EAS. The contract path never calls updateVersionUid, so the versions table
+ * may have uid=NULL. EAS fallback queries attestations where refUID=seedUid (Version attestations).
+ */
+async function resolveVersionUid(seedLocalId, seedUid) {
+    if (!seedLocalId || !seedUid || seedUid === ZERO_BYTES32)
+        return ZERO_BYTES32;
+    const appDb = BaseDb.getAppDb();
+    if (appDb) {
+        const rows = await appDb
+            .select({ uid: versions.uid })
+            .from(versions)
+            .where(eq(versions.seedLocalId, seedLocalId))
+            .orderBy(desc(versions.createdAt))
+            .limit(1);
+        const uid = rows[0]?.uid;
+        if (uid && uid !== '' && uid !== 'NULL')
+            return uid;
+    }
+    try {
+        const _mod_0 = await import('./index-uPXtq2cf.js');
+        const _ns_0 = _mod_0.br;
+        const { getItemVersionsFromEas } = _ns_0;
+        const attestations = await getItemVersionsFromEas({ seedUids: [seedUid] });
+        const latest = attestations?.[0];
+        if (latest?.id)
+            return latest.id;
+    }
+    catch {
+        // EAS client may not be initialized or network error
+    }
+    return ZERO_BYTES32;
+}
+const getPropertyData = async (itemProperty, ctx) => {
+    const dataType = itemProperty.propertyDef?.dataType;
+    const entry = dataType != null ? INTERNAL_DATA_TYPES[dataType] : undefined;
+    const easDataType = entry?.eas;
+    if (!easDataType) {
+        if (ctx) {
+            addValidationError(ctx, `Unknown or unsupported property data type "${dataType ?? 'undefined'}" for property: ${itemProperty.propertyName}. Supported types: ${Object.keys(INTERNAL_DATA_TYPES).join(', ')}.`, itemProperty.propertyName);
+        }
+        return null;
+    }
+    let schemaUid = itemProperty.schemaUid;
+    const ip = itemProperty;
+    const nameForEas = ip.storagePropertyName && ip.storagePropertyName.length > 0
+        ? ip.storagePropertyName
+        : itemProperty.propertyName;
+    const propertyNameForSchema = toSnakeCase$1(nameForEas);
+    const schemaDef = `${easDataType} ${propertyNameForSchema}`;
+    if (!schemaUid) {
+        schemaUid = await getEasSchemaUidForSchemaDefinition({ schemaText: schemaDef });
+        if (!schemaUid) {
+            const schema = await getEasSchemaForItemProperty({
+                propertyName: 'version',
+                easDataType: 'bytes32',
+            });
+            if (schema) {
+                schemaUid = schema.id;
+            }
+        }
+    }
+    return {
+        schemaUid,
+        easDataType,
+        schemaDef,
+        propertyNameForSchema,
+    };
+};
+/** Resolve propertyDef from Model for properties that lack it (e.g. cached instances
+ * created before loadOrCreateProperty was fixed). Ensures both new and existing items get property attestations.
+ * Also ensures Relation/Image properties have required from schema when missing (for publish validation). */
+const ensurePropertyDefs = async (targetItem) => {
+    targetItem.properties.filter((p) => targetItem.modelName &&
+        (!p.propertyDef || (p.propertyDef?.dataType === 'Relation' && p.propertyDef?.required === undefined)));
+    let schema;
+    for (const itemProperty of targetItem.properties) {
+        if (!itemProperty.propertyDef && targetItem.modelName) {
+            schema = await getPropertySchema(targetItem.modelName, itemProperty.propertyName);
+            if (!schema) {
+                try {
+                    const _mod_1 = await import('./index-uPXtq2cf.js');
+                    const _ns_1 = _mod_1.bv;
+                    const { Model } = _ns_1;
+                    const normalizedModelName = upperFirst(camelCase(targetItem.modelName));
+                    let model = Model.getByName(normalizedModelName);
+                    if (!model?.properties?.length) {
+                        model = Model.findByModelType(toSnakeCase(targetItem.modelName));
+                    }
+                    const modelFound = !!model;
+                    const propsCount = model?.properties?.length ?? 0;
+                    const schemaKeys = [];
+                    if (model?.properties?.length) {
+                        const schemas = modelPropertiesToObject(model.properties);
+                        schemaKeys.push(...Object.keys(schemas));
+                        schema = schemas[itemProperty.propertyName];
+                    }
+                }
+                catch (err) {
+                    schema = undefined;
+                }
+            }
+            if (!schema) {
+                const db = BaseDb.getAppDb();
+                if (db) {
+                    try {
+                        const normalizedModelName = upperFirst(camelCase(targetItem.modelName));
+                        const modelRecords = await db
+                            .select({ id: models.id })
+                            .from(models)
+                            .where(eq(models.name, normalizedModelName))
+                            .limit(1);
+                        if (modelRecords.length > 0 && modelRecords[0].id) {
+                            const propertyRecords = await db
+                                .select()
+                                .from(properties)
+                                .where(and(eq(properties.modelId, modelRecords[0].id), eq(properties.name, itemProperty.propertyName)))
+                                .limit(1);
+                            if (propertyRecords.length > 0) {
+                                const propRecord = propertyRecords[0];
+                                let refModelName;
+                                if (propRecord.refModelId != null) {
+                                    const refModelRows = await db
+                                        .select({ name: models.name })
+                                        .from(models)
+                                        .where(eq(models.id, propRecord.refModelId))
+                                        .limit(1);
+                                    refModelName = refModelRows[0]?.name ?? undefined;
+                                }
+                                schema = {
+                                    dataType: propRecord.dataType,
+                                    ref: refModelName ?? undefined,
+                                    refValueType: propRecord.refValueType || undefined,
+                                    storageType: propRecord.storageType || undefined,
+                                    localStorageDir: propRecord.localStorageDir || undefined,
+                                    filenameSuffix: propRecord.filenameSuffix || undefined,
+                                    required: propRecord.required ?? undefined,
+                                };
+                            }
+                        }
+                    }
+                    catch {
+                        schema = undefined;
+                    }
+                }
+            }
+            if (schema) {
+                itemProperty.getService().send({
+                    type: 'updateContext',
+                    propertyRecordSchema: schema,
+                });
+            }
+        }
+    }
+};
+// Lazy import SchemaEncoder to avoid module resolution issues with ts-import
+let SchemaEncoderClass = null;
+const getSchemaEncoder = async () => {
+    if (!SchemaEncoderClass) {
+        const easSdk = await import('@ethereum-attestation-service/eas-sdk');
+        SchemaEncoderClass = easSdk.SchemaEncoder;
+    }
+    return SchemaEncoderClass;
+};
+const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx) => {
+    for (const basicProperty of itemBasicProperties) {
+        // Skip SDK-internal properties (e.g. publisher) - never attest to EAS
+        if (INTERNAL_PROPERTY_NAMES.includes(basicProperty.propertyName)) {
+            continue;
+        }
+        const snapshot = basicProperty.getService().getSnapshot();
+        const context = 'context' in snapshot ? snapshot.context : null;
+        const propertyDef = basicProperty.propertyDef ?? (context ? context.propertyRecordSchema : undefined);
+        const isFileImageHtml = propertyDef?.dataType === ModelPropertyDataTypes.File ||
+            propertyDef?.dataType === ModelPropertyDataTypes.Image ||
+            propertyDef?.dataType === ModelPropertyDataTypes.Html;
+        // File/Image/Html must use propertyValue (seed ID), not basicProperty.value which returns
+        // renderValue (file content) for File—bytes32 can only hold 31 bytes.
+        let value = isFileImageHtml && context
+            ? context.propertyValue
+            : (basicProperty.value ??
+                (context ? context.propertyValue : undefined));
+        !!basicProperty.uid;
+        if (!context) {
+            continue;
+        }
+        if (!value || basicProperty.uid) {
+            continue;
+        }
+        const propertyData = await getPropertyData(basicProperty, ctx);
+        if (!propertyData)
+            continue;
+        const { schemaUid, easDataType, schemaDef, propertyNameForSchema } = propertyData;
+        if (!schemaDef)
+            continue;
+        // Normalize value: string that parses to array (e.g. from browser storage) -> array
+        if (schemaDef.startsWith('bytes32[]') && typeof value === 'string' && value.trim().startsWith('[')) {
+            try {
+                value = JSON.parse(value);
+            }
+            catch {
+                // fall through to array check
+            }
+        }
+        // Legacy comma-separated ids (pre-JSON List storage)
+        if (schemaDef.startsWith('bytes32[]') &&
+            typeof value === 'string' &&
+            !value.trim().startsWith('[') &&
+            value.includes(',')) {
+            value = value
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+        if (schemaDef.startsWith('bytes32[]') && !Array.isArray(value)) {
+            addValidationError(ctx, `Invalid value for property: ${basicProperty.propertyName}. Expected an array of bytes32, got ${value}.`, basicProperty.propertyName);
+            continue;
+        }
+        // Validate against property validation rules (enum, pattern, minLength, maxLength) before encoding
+        if (propertyDef?.validation) {
+            const { SchemaValidationService } = await import('./SchemaValidationService-DXxRk-9Q.js');
+            const validationService = new SchemaValidationService();
+            const validationResult = validationService.validatePropertyValue(value, propertyDef.dataType, propertyDef.validation, propertyDef.refValueType);
+            if (!validationResult.isValid && validationResult.errors.length > 0) {
+                const firstError = validationResult.errors[0];
+                addValidationError(ctx, firstError.message, basicProperty.propertyName, firstError.code ?? 'publish_validation');
+                continue;
+            }
+        }
+        if (schemaDef.startsWith('bytes32[]')) {
+            const newValues = [];
+            const iterableValue = Array.isArray(value) ? value
+                : value != null && typeof value[Symbol.iterator] === 'function' ? value
+                    : [];
+            for (const seedId of iterableValue) {
+                if (seedId.length !== 66 && !seedId.startsWith('0x')) {
+                    newValues.push(ethers.encodeBytes32String(seedId));
+                    continue;
+                }
+                newValues.push(seedId);
+            }
+            value = newValues;
+        }
+        // uint256 (Date) must be numeric/BigInt; normalize ISO strings to Unix seconds
+        if (easDataType === 'uint256' && (typeof value === 'string' || value instanceof Date)) {
+            const ms = value instanceof Date ? value.getTime() : new Date(value).getTime();
+            value = BigInt(Math.floor(ms / 1000));
+        }
+        let data = [
+            {
+                name: propertyNameForSchema,
+                type: easDataType,
+                value,
+            },
+        ];
+        let encodedData;
+        try {
+            const SchemaEncoder = await getSchemaEncoder();
+            const dataEncoder = new SchemaEncoder(schemaDef);
+            encodedData = dataEncoder.encodeData(data);
+        }
+        catch (encodeErr) {
+            addValidationError(ctx, `Failed to encode property ${basicProperty.propertyName}: ${encodeErr instanceof Error ? encodeErr.message : String(encodeErr)}`, basicProperty.propertyName);
+            continue;
+        }
+        // For storageTransactionId, set refUID to versionUid so it references the Version attestation (contract may use when supported)
+        const refUid = basicProperty.propertyName === 'storageTransactionId'
+            ? itemPublishData.versionUid
+            : defaultAttestationData.refUID;
+        const attestationEntry = {
+            schema: schemaUid,
+            data: [
+                {
+                    ...defaultAttestationData,
+                    refUID: refUid,
+                    data: encodedData,
+                },
+            ],
+        };
+        // For relation/image properties with seedLocalId, store resolution hints for resolvePublishPayloadValues
+        if (typeof value === 'string' &&
+            value.length === 10 &&
+            (easDataType === 'bytes32' || easDataType === 'string')) {
+            attestationEntry._propertyName = basicProperty.propertyName;
+            attestationEntry._schemaDef = schemaDef;
+            attestationEntry._unresolvedValue = value;
+            attestationEntry._easDataType = easDataType;
+        }
+        itemPublishData.listOfAttestations.push(attestationEntry);
+    }
+    return itemPublishData;
+};
+const processRelationOrImageProperty = async (relationOrImageProperty, multiPublishPayload, uploadedTransactions, originalSeedLocalId, ctx) => {
+    let relationOrImageSchemaUid = relationOrImageProperty.schemaUid;
+    if (!relationOrImageSchemaUid && relationOrImageProperty.propertyDef) {
+        const propertyData = await getPropertyData(relationOrImageProperty, ctx);
+        if (!propertyData)
+            return multiPublishPayload;
+        relationOrImageSchemaUid = propertyData.schemaUid;
+    }
+    if (!relationOrImageSchemaUid) {
+        addValidationError(ctx, `Schema uid not found for relation or image property: ${relationOrImageProperty.propertyName}`, relationOrImageProperty.propertyName);
+        return multiPublishPayload;
+    }
+    const snapshot = relationOrImageProperty.getService().getSnapshot();
+    const context = 'context' in snapshot ? snapshot.context : null;
+    if (!context) {
+        return multiPublishPayload;
+    }
+    let value = context.propertyValue;
+    // File/Image/Html/Json metadata is stored with Id suffix (e.g. "textId"); context may not have propertyValue
+    // if the property was created from schema before metadata loaded. Fallback to metadata lookup.
+    const isStorageSeed = relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.File ||
+        relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.Image ||
+        relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.Html ||
+        relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.Json ||
+        (relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.Relation &&
+            (relationOrImageProperty.propertyDef?.refValueType === ModelPropertyDataTypes.File ||
+                relationOrImageProperty.propertyDef?.refValueType === ModelPropertyDataTypes.Image ||
+                relationOrImageProperty.propertyDef?.refValueType === ModelPropertyDataTypes.Html ||
+                relationOrImageProperty.propertyDef?.refValueType === ModelPropertyDataTypes.Json));
+    if (!value && isStorageSeed && (context.seedLocalId || context.seedUid)) {
+        const _mod_2 = await import('./index-uPXtq2cf.js');
+        const _ns_2 = _mod_2.bs;
+        const { getPropertyData: getPropertyDataFromDb } = _ns_2;
+        const metaRow = await getPropertyDataFromDb({
+            propertyName: relationOrImageProperty.propertyName,
+            seedLocalId: context.seedLocalId,
+            seedUid: context.seedUid,
+        });
+        const fromMeta = metaRow?.propertyValue;
+        if (fromMeta && typeof fromMeta === 'string' && fromMeta.trim() !== '') {
+            value = fromMeta;
+        }
+    }
+    const propertyDef = relationOrImageProperty.propertyDef;
+    let isRequired = propertyDef?.required === true;
+    // Resolve required from schema/DB when propertyDef lacks it
+    if (!isRequired && relationOrImageProperty.modelName) {
+        let schema = await getPropertySchema(relationOrImageProperty.modelName, relationOrImageProperty.propertyName);
+        if (!schema && BaseDb.getAppDb()) {
+            const normalizedModelName = upperFirst(camelCase(relationOrImageProperty.modelName));
+            const modelRecords = await BaseDb.getAppDb()
+                .select({ id: models.id })
+                .from(models)
+                .where(eq(models.name, normalizedModelName))
+                .limit(1);
+            if (modelRecords.length > 0 && modelRecords[0].id) {
+                const propertyRecords = await BaseDb.getAppDb()
+                    .select()
+                    .from(properties)
+                    .where(and(eq(properties.modelId, modelRecords[0].id), eq(properties.name, relationOrImageProperty.propertyName)))
+                    .limit(1);
+                if (propertyRecords.length > 0) {
+                    schema = {
+                        dataType: propertyRecords[0].dataType,
+                        ref: undefined,
+                        required: propertyRecords[0].required ?? undefined,
+                    };
+                }
+            }
+        }
+        if (schema?.required === true || schema?.required === 1) {
+            isRequired = true;
+        }
+    }
+    // Required relation/image/file/html/json with no value: cannot publish
+    if (isRequired && !value) {
+        const typeLabel = propertyDef?.dataType === ModelPropertyDataTypes.File ||
+            propertyDef?.refValueType === ModelPropertyDataTypes.File
+            ? 'file'
+            : propertyDef?.dataType === ModelPropertyDataTypes.Image ||
+                propertyDef?.refValueType === ModelPropertyDataTypes.Image
+                ? 'image'
+                : propertyDef?.dataType === ModelPropertyDataTypes.Html ||
+                    propertyDef?.refValueType === ModelPropertyDataTypes.Html
+                    ? 'html'
+                    : propertyDef?.dataType === ModelPropertyDataTypes.Json ||
+                        propertyDef?.refValueType === ModelPropertyDataTypes.Json
+                        ? 'json'
+                        : 'relation';
+        const refLabel = propertyDef?.ref ?? propertyDef?.refModelName ?? 'related';
+        addValidationError(ctx, `Required ${typeLabel} ${relationOrImageProperty.propertyName} has no value. ` +
+            `A value pointing to a valid ${refLabel} item is required to publish.`, relationOrImageProperty.propertyName);
+        return multiPublishPayload;
+    }
+    if (!value || relationOrImageProperty.uid) {
+        return multiPublishPayload;
+    }
+    const { localId: seedLocalId, uid: seedUid } = getCorrectId(value);
+    // Value is not a valid seed reference (10-char localId or 66-char uid)
+    if (!seedLocalId && !seedUid) {
+        if (isRequired) {
+            addValidationError(ctx, `Required relation ${relationOrImageProperty.propertyName} has invalid value: ${JSON.stringify(value)}. ` +
+                `Value must be a valid seed reference (localId or uid) pointing to a ${propertyDef?.ref ?? propertyDef?.refModelName ?? 'related'} item.`, relationOrImageProperty.propertyName);
+        }
+        return multiPublishPayload;
+    }
+    // Use dynamic import to break circular dependency
+    const getItemMod = await import('./getItem-ClK0UZqi.js');
+    const { getItem } = getItemMod;
+    const relatedItem = await getItem({
+        seedLocalId,
+        seedUid,
+    });
+    // When related item not found (e.g. different DB, not yet created)
+    if (!relatedItem) {
+        if (isRequired) {
+            addValidationError(ctx, `No related item found for required relation: ${relationOrImageProperty.propertyName}. ` +
+                `Value: ${JSON.stringify(value)} (seedLocalId/seedUid). ` +
+                `The related item may be missing, in a different database, or the reference may be broken.`, relationOrImageProperty.propertyName);
+        }
+        return multiPublishPayload;
+    }
+    // When Image/Relation already has seedUid (published), skip creating its payload—only add the property to parent
+    if (relatedItem.seedUid) {
+        return multiPublishPayload;
+    }
+    const versionUid = getVersionUid(relatedItem);
+    let modelName;
+    if (relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.Image) {
+        modelName = 'Image';
+    }
+    if (relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.File) {
+        modelName = 'File';
+    }
+    if (relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.Html) {
+        modelName = 'Html';
+    }
+    if (relationOrImageProperty.propertyDef?.dataType === ModelPropertyDataTypes.Relation) {
+        const def = relationOrImageProperty.propertyDef;
+        modelName = def.ref ?? def.refModelName;
+    }
+    if (!modelName) {
+        addValidationError(ctx, `Model name not found for relation or image property: ${relationOrImageProperty.propertyName}`, relationOrImageProperty.propertyName);
+        return multiPublishPayload;
+    }
+    const seedSchemaUid = await getEasSchemaUidForModel(modelName);
+    if (!seedSchemaUid) {
+        addValidationError(ctx, `Schema UID not found for model: ${modelName}`, relationOrImageProperty.propertyName);
+        return multiPublishPayload;
+    }
+    let publishPayload = {
+        localId: relatedItem.seedLocalId,
+        seedIsRevocable: true,
+        versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+        seedUid: seedUid || ZERO_BYTES32,
+        seedSchemaUid,
+        versionUid,
+        listOfAttestations: [],
+        propertiesToUpdate: [
+            {
+                publishLocalId: originalSeedLocalId,
+                propertySchemaUid: relationOrImageSchemaUid,
+            },
+        ],
+    };
+    await ensurePropertyDefs(relatedItem);
+    const { itemBasicProperties, itemUploadProperties } = await getSegmentedItemProperties(relatedItem);
+    if (itemUploadProperties.length === 1) {
+        const uploadProperty = itemUploadProperties[0];
+        const itemProperty = uploadProperty.itemProperty;
+        const transactionData = uploadedTransactions.find((transaction) => transaction.seedLocalId === relatedItem.seedLocalId);
+        if (transactionData) {
+            itemProperty.value = transactionData.txId;
+            await itemProperty.save();
+            itemBasicProperties.push(itemProperty);
+        }
+    }
+    publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx);
+    multiPublishPayload.push(publishPayload);
+    return multiPublishPayload;
+};
+const processListProperty = async (listProperty, multiPublishPayload, originalSeedLocalId, ctx) => {
+    // processListProperty only handles list-of-relations; list-of-primitives go to itemBasicProperties
+    if (!listProperty.propertyDef?.ref) {
+        addValidationError(ctx, `processListProperty requires ref (list of relations). List property "${listProperty.propertyName}" has no ref. List-of-primitives should be in itemBasicProperties.`, listProperty.propertyName);
+        return multiPublishPayload;
+    }
+    let listPropertySchemaUid = listProperty.schemaUid;
+    if (!listPropertySchemaUid && listProperty.propertyDef) {
+        const propertyData = await getPropertyData(listProperty, ctx);
+        if (!propertyData)
+            return multiPublishPayload;
+        listPropertySchemaUid = propertyData.schemaUid;
+    }
+    if (!listPropertySchemaUid) {
+        addValidationError(ctx, `Schema uid not found for list property: ${listProperty.propertyName}`, listProperty.propertyName);
+        return multiPublishPayload;
+    }
+    const snapshot = listProperty.getService().getSnapshot();
+    const context = 'context' in snapshot ? snapshot.context : null;
+    if (!context) {
+        return multiPublishPayload;
+    }
+    let value = context.propertyValue;
+    if (!value || listProperty.uid) {
+        return multiPublishPayload;
+    }
+    const singularPropertyName = pluralize.singular(listProperty.propertyName);
+    `${singularPropertyName}${listProperty.propertyDef.ref}Ids`;
+    if (typeof value === 'string') {
+        value = parseListPropertyValueFromStorage(value);
+    }
+    const iterableValue = Array.isArray(value)
+        ? value
+        : value != null
+            ? [value]
+            : [];
+    for (const seedId of iterableValue) {
+        const idStr = typeof seedId === 'string'
+            ? seedId
+            : seedId &&
+                typeof seedId === 'object' &&
+                (seedId.seedLocalId ?? seedId.seedUid ?? seedId.localId ?? seedId.uid);
+        if (!idStr)
+            continue;
+        const { localId: seedLocalId, uid: seedUid } = getCorrectId(idStr);
+        if (!seedLocalId && !seedUid)
+            continue;
+        // Use dynamic import to break circular dependency
+        const getItemMod = await import('./getItem-ClK0UZqi.js');
+        const { getItem } = getItemMod;
+        const relatedItem = await getItem({
+            seedLocalId,
+            seedUid,
+        });
+        if (!relatedItem) {
+            console.error(`No related item found for list property: ${listProperty.propertyName}`);
+            continue;
+        }
+        if (relatedItem.seedUid) {
+            continue;
+        }
+        const versionUid = getVersionUid(relatedItem);
+        let modelName;
+        if (listProperty.propertyDef?.ref || listProperty.propertyDef.refModelName) {
+            const def = listProperty.propertyDef;
+            modelName = def.ref ?? def.refModelName;
+        }
+        if (listProperty.propertyDef?.dataType === ModelPropertyDataTypes.Image) {
+            modelName = 'Image';
+        }
+        if (listProperty.propertyDef?.dataType === ModelPropertyDataTypes.File) {
+            modelName = 'File';
+        }
+        if (listProperty.propertyDef?.dataType === ModelPropertyDataTypes.Html) {
+            modelName = 'Html';
+        }
+        if (!modelName) {
+            addValidationError(ctx, `Model name not found for list property: ${listProperty.propertyName}`, listProperty.propertyName);
+            continue;
+        }
+        const seedSchemaUid = await getEasSchemaUidForModel(modelName);
+        if (!seedSchemaUid) {
+            addValidationError(ctx, `Schema UID not found for model: ${modelName}`, listProperty.propertyName);
+            continue;
+        }
+        let publishPayload = {
+            localId: relatedItem.seedLocalId,
+            seedIsRevocable: true,
+            versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+            seedUid: seedUid || ZERO_BYTES32,
+            seedSchemaUid,
+            versionUid,
+            listOfAttestations: [],
+            propertiesToUpdate: [
+                {
+                    publishLocalId: originalSeedLocalId,
+                    propertySchemaUid: listPropertySchemaUid,
+                },
+            ],
+        };
+        await ensurePropertyDefs(relatedItem);
+        const { itemBasicProperties } = await getSegmentedItemProperties(relatedItem);
+        publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx);
+        multiPublishPayload.push(publishPayload);
+    }
+    return multiPublishPayload;
+};
+/** Error thrown when publish validation fails. Includes all validation errors for user to fix. */
+class PublishValidationFailedError extends Error {
+    constructor(message, validationErrors) {
+        super(message);
+        this.validationErrors = validationErrors;
+        this.name = 'PublishValidationFailedError';
+    }
+}
+const getPublishPayload = async (item, uploadedTransactions) => {
+    const validationCtx = { errors: [] };
+    let multiPublishPayload = [];
+    // Each PublishPayload is generated from a Seed that needs publishing
+    // First we need to determine all Seeds to publish
+    // That means the Seed of the Item, plus any Seeds pointed to by Relations
+    // Check if the item has a schema UID
+    let itemSchemaUid = item.schemaUid;
+    if (!itemSchemaUid) {
+        const schemaUid = await getEasSchemaUidForModel(item.modelName);
+        if (!schemaUid) {
+            addValidationError(validationCtx, `Schema UID not found for model: ${item.modelName}`);
+            itemSchemaUid = ZERO_BYTES32; // placeholder so we can continue collecting errors
+        }
+        else {
+            itemSchemaUid = schemaUid;
+        }
+    }
+    let versionUid = getVersionUid(item);
+    if (versionUid === ZERO_BYTES32 && item.seedUid && item.seedUid !== ZERO_BYTES32) {
+        versionUid = await resolveVersionUid(item.seedLocalId, item.seedUid);
+    }
+    let itemPublishData = {
+        localId: item.seedLocalId,
+        seedUid: item.seedUid || ZERO_BYTES32,
+        seedIsRevocable: true,
+        seedSchemaUid: itemSchemaUid,
+        versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+        versionUid,
+        listOfAttestations: [],
+        propertiesToUpdate: [],
+    };
+    await ensurePropertyDefs(item);
+    const { itemBasicProperties, itemListProperties, itemUploadProperties, itemImageProperties, itemRelationProperties, } = await getSegmentedItemProperties(item);
+    const relationAndImageProperties = [...itemRelationProperties, ...itemImageProperties];
+    // Validate required relations have values before processing
+    for (const relProp of itemRelationProperties) {
+        const snapshot = relProp.getService().getSnapshot();
+        const ctx = 'context' in snapshot ? snapshot.context : null;
+        const val = ctx ? ctx.renderValue ?? ctx.propertyValue : undefined;
+        if (val != null && typeof val === 'string' && val.trim() !== '')
+            continue;
+        // No value - check if required from propertyDef or DB
+        let isRequired = relProp.propertyDef?.required === true;
+        if (!isRequired && BaseDb.getAppDb() && item.modelName) {
+            const normalizedModelName = upperFirst(camelCase(item.modelName));
+            const modelRows = await BaseDb.getAppDb()
+                .select({ id: models.id })
+                .from(models)
+                .where(eq(models.name, normalizedModelName))
+                .limit(1);
+            if (modelRows.length > 0) {
+                const propRows = await BaseDb.getAppDb()
+                    .select({ required: properties.required, refModelId: properties.refModelId })
+                    .from(properties)
+                    .where(and(eq(properties.modelId, modelRows[0].id), eq(properties.name, relProp.propertyName), eq(properties.dataType, 'Relation')))
+                    .limit(1);
+                if (propRows.length > 0 && (propRows[0].required === true || propRows[0].required === 1)) {
+                    isRequired = true;
+                }
+            }
+        }
+        if (isRequired) {
+            const refModel = relProp.propertyDef?.ref ?? relProp.propertyDef?.refModelName ?? 'related';
+            addValidationError(validationCtx, `Required relation ${relProp.propertyName} has no value. ` +
+                `A value pointing to a valid ${refModel} item is required to publish.`, relProp.propertyName);
+        }
+    }
+    if (itemUploadProperties.length === 1) {
+        const uploadProperty = itemUploadProperties[0];
+        const itemProperty = uploadProperty.itemProperty;
+        const transactionData = uploadedTransactions.find((transaction) => transaction.seedLocalId === item.seedLocalId);
+        if (transactionData) {
+            itemProperty.value = transactionData.txId;
+            await itemProperty.save();
+            itemBasicProperties.push(itemProperty);
+        }
+    }
+    for (const relationProperty of relationAndImageProperties) {
+        multiPublishPayload = await processRelationOrImageProperty(relationProperty, multiPublishPayload, uploadedTransactions, item.seedLocalId, validationCtx);
+        itemBasicProperties.push(relationProperty);
+    }
+    for (const listProperty of itemListProperties) {
+        multiPublishPayload = await processListProperty(listProperty, multiPublishPayload, item.seedLocalId, validationCtx);
+        itemBasicProperties.push(listProperty);
+    }
+    itemPublishData = await processBasicProperties(itemBasicProperties, itemPublishData, validationCtx);
+    multiPublishPayload.push(itemPublishData);
+    // Ensure requests are ordered so that when A has propertiesToUpdate pointing to B (publishLocalId),
+    // A (the updater) is published before B (the updatee). The contract injects A's seedUid into B's
+    // attestation before B is sent to EAS.
+    multiPublishPayload = orderPayloadByDependencies(multiPublishPayload);
+    // Ensure attestations referenced in propertiesToUpdate have at least one data element.
+    // The contract writes the seed UID into data[0].data; empty data causes Panic 50.
+    multiPublishPayload = ensurePropertiesToUpdateAttestationsHaveData(multiPublishPayload);
+    if (validationCtx.errors.length > 0) {
+        const combinedMessage = validationCtx.errors.map((e) => e.message).join('\n');
+        throw new PublishValidationFailedError(`Validation failed (${validationCtx.errors.length} error${validationCtx.errors.length === 1 ? '' : 's'}):\n${combinedMessage}`, validationCtx.errors);
+    }
+    return multiPublishPayload;
+};
+/**
+ * Validates an item for publishing without performing Arweave or EAS work.
+ * Use in the checking step to fail fast before creating transactions.
+ * Pass empty array for uploadedTransactions when validating before Arweave upload.
+ */
+const validateItemForPublish = async (item, uploadedTransactions = []) => {
+    try {
+        await getPublishPayload(item, uploadedTransactions);
+        return { isValid: true, errors: [] };
+    }
+    catch (err) {
+        if (err instanceof PublishValidationFailedError) {
+            return { isValid: false, errors: err.validationErrors };
+        }
+        throw err;
+    }
+};
+/**
+ * Normalize a schema UID to 0x-prefixed 64-char hex for comparison.
+ */
+function normalizeSchemaUid(v) {
+    if (v == null || v === '')
+        return '';
+    const raw = v.startsWith('0x') ? v.slice(2) : v;
+    const hex = raw.replace(/[^0-9a-fA-F]/g, '0').padStart(64, '0').slice(-64);
+    return ('0x' + hex).toLowerCase();
+}
+/**
+ * Ensure that when request A has propertiesToUpdate with (publishLocalId: B, propertySchemaUid: X),
+ * request B has an attestation for schema X with at least one data element. The contract writes
+ * the seed UID into data[0].data; empty data causes Panic 50.
+ */
+function ensurePropertiesToUpdateAttestationsHaveData(payload) {
+    const byLocalId = new Map();
+    for (const p of payload) {
+        byLocalId.set(p.localId, p);
+    }
+    const placeholderData = {
+        ...defaultAttestationData,
+        data: ZERO_BYTES32,
+    };
+    for (const req of payload) {
+        for (const pu of req.propertiesToUpdate ?? []) {
+            const targetId = pu.publishLocalId;
+            const schemaUid = pu.propertySchemaUid;
+            if (!targetId || !schemaUid)
+                continue;
+            const targetReq = byLocalId.get(targetId);
+            if (!targetReq?.listOfAttestations)
+                continue;
+            const wantSchema = normalizeSchemaUid(schemaUid);
+            const att = targetReq.listOfAttestations.find((a) => normalizeSchemaUid(a?.schema) === wantSchema);
+            if (!att)
+                continue;
+            if (!Array.isArray(att.data) || att.data.length === 0) {
+                att.data = [placeholderData];
+            }
+        }
+    }
+    return payload;
+}
+/**
+ * Topological sort: when request A has propertiesToUpdate with publishLocalId B,
+ * A (the updater) must appear before B (the updatee). The contract injects A's seedUid
+ * into B's attestation before B is sent to EAS; if B is processed first, B's attestation
+ * goes out with wrong data (string instead of bytes32).
+ */
+function orderPayloadByDependencies(payload) {
+    const byLocalId = new Map();
+    for (const p of payload) {
+        byLocalId.set(p.localId, p);
+    }
+    const visited = new Set();
+    const result = [];
+    const visit = (localId) => {
+        if (visited.has(localId))
+            return;
+        visited.add(localId);
+        const p = byLocalId.get(localId);
+        if (!p)
+            return;
+        result.push(p);
+        for (const u of p.propertiesToUpdate ?? []) {
+            const targetId = u.publishLocalId;
+            if (targetId && targetId !== localId)
+                visit(targetId);
+        }
+    };
+    for (const p of payload) {
+        visit(p.localId);
+    }
+    return result;
+}
+/**
+ * Resolves relation/image property values (seedLocalId) to attestation uids after dependent seeds are published.
+ * Call after each payload is published, passing the returned attestation uid for that seed's localId.
+ * Returns an updated multiPayload with re-encoded attestations where resolution was applied.
+ */
+const resolvePublishPayloadValues = async (multiPayload, resolvedUids) => {
+    if (Object.keys(resolvedUids).length === 0) {
+        return multiPayload;
+    }
+    const SchemaEncoder = await getSchemaEncoder();
+    const result = [];
+    for (const payload of multiPayload) {
+        const updatedAttestations = [];
+        for (const attestation of payload.listOfAttestations) {
+            const entry = attestation;
+            const resolvedUid = entry._unresolvedValue && resolvedUids[entry._unresolvedValue];
+            if (resolvedUid && entry._schemaDef && entry._propertyName) {
+                const propertyNameForSchema = toSnakeCase$1(entry._propertyName);
+                const dataEncoder = new SchemaEncoder(entry._schemaDef);
+                const encodedData = dataEncoder.encodeData([
+                    {
+                        name: propertyNameForSchema,
+                        type: entry._easDataType || 'bytes32',
+                        value: resolvedUid,
+                    },
+                ]);
+                const baseData = Array.isArray(entry.data) ? entry.data[0] : entry.data;
+                updatedAttestations.push({
+                    ...entry,
+                    data: [
+                        {
+                            ...baseData,
+                            data: encodedData,
+                        },
+                    ],
+                    _unresolvedValue: undefined,
+                });
+            }
+            else {
+                const normalizedEntry = {
+                    ...entry,
+                    data: Array.isArray(entry.data) ? entry.data : [entry.data],
+                };
+                updatedAttestations.push(normalizedEntry);
+            }
+        }
+        result.push({
+            ...payload,
+            listOfAttestations: updatedAttestations,
+        });
+    }
+    return result;
+};
+
+export { PublishValidationFailedError, getPublishPayload, resolvePublishPayloadValues, validateItemForPublish };
+//# sourceMappingURL=getPublishPayload-CdfPTl8l.js.map