@seedprotocol/sdk 0.1.70 → 0.1.72

package/dist/{index-B6WilINl.js → index-CG7KjAdn.js}

@@ -1,5 +1,7 @@
-export { f as GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, e as GET_PROPERTIES, G as GET_SCHEMAS, a as GET_SEEDS, b as GET_SEED_IDS, c as GET_STORAGE_TRANSACTION_ID, d as GET_VERSIONS, I as Item, g as itemMachineAll, i as itemMachineSingle } from './index-Cy1fke9s.js';
-import './constants-BLctWkrn.js';
+export { g as GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, f as GET_PROPERTIES, G as GET_SCHEMAS, a as GET_SCHEMA_BY_NAME, b as GET_SEEDS, c as GET_SEED_IDS, d as GET_STORAGE_TRANSACTION_ID, e as GET_VERSIONS, I as Item, h as itemMachineAll, i as itemMachineSingle } from './index-Bcf8xGUK.js';
+import './constants-CtmwCBma.js';
+import '@ethereum-attestation-service/eas-sdk';
+import 'thirdweb';
 import 'path';
 import 'reflect-metadata';
 import '@sinclair/typebox';
@@ -27,4 +29,4 @@ import '@zenfs/dom';
 import 'arweave';
 import 'use-immer';
 import '@xstate/react';
-//# sourceMappingURL=index-B6WilINl.js.map
+//# sourceMappingURL=index-CG7KjAdn.js.map

package/dist/index-CG7KjAdn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CG7KjAdn.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/main.js

@@ -1,7 +1,7 @@
-export { h as ImageSrc, I as Item, j as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, s as client, t as getCorrectId, r as getGlobalService, m as useCreateItem, o as useDeleteItem, p as useGlobalServiceStatus, k as useItem, l as useItemProperties, n as useItemProperty, u as useItems, q as useServices, w as withSeed } from './index-Cy1fke9s.js';
+export { j as ImageSrc, I as Item, k as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, t as client, v as getCorrectId, s as getGlobalService, n as useCreateItem, p as useDeleteItem, q as useGlobalServiceStatus, l as useItem, m as useItemProperties, o as useItemProperty, u as useItems, r as useServices, w as withSeed } from './index-Bcf8xGUK.js';
 import 'immer';
 import 'reflect-metadata';
-import './constants-BLctWkrn.js';
+import './constants-CtmwCBma.js';
 import 'xstate';
 import 'arweave';
 import 'drizzle-orm';
@@ -27,4 +27,6 @@ import 'drizzle-orm/sqlite-proxy';
 import '@zenfs/dom';
 import 'use-immer';
 import '@xstate/react';
+import 'thirdweb';
+import '@ethereum-attestation-service/eas-sdk';
 //# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -1 +1 @@
-{"version":3,"file":"main.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/{seed.schema.config-dylVDX7W.js → seed.schema.config-Z67FC09h.js}

@@ -1,12 +1,14 @@
-import { _ as __decorate, a as __metadata } from './constants-BLctWkrn.js';
+import { _ as __decorate, a as __metadata } from './constants-CtmwCBma.js';
 import 'drizzle-orm';
-import { T as Text, M as Model } from './index-Cy1fke9s.js';
+import { T as Text, M as Model } from './index-Bcf8xGUK.js';
 import 'react';
 import 'reflect-metadata';
 import 'xstate';
 import 'arweave';
 import '@zenfs/core';
 import '@zenfs/dom';
+import '@ethereum-attestation-service/eas-sdk';
+import 'thirdweb';
 import 'path';
 import '@sinclair/typebox';
 import 'dayjs';
@@ -74,4 +76,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-dylVDX7W.js.map
+//# sourceMappingURL=seed.schema.config-Z67FC09h.js.map

package/dist/seed.schema.config-Z67FC09h.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.schema.config-Z67FC09h.js","sources":["../../src/shared/configs/seed.schema.config.ts"],"sourcesContent":["import { Model, Text } from '@/browser'\n\n@Model\nclass Seed {\n  @Text() uid!: string\n  @Text() type!: string\n}\n\n@Model\nclass Version {\n  @Text() seedUid!: string\n  @Text() note!: string\n}\n\n@Model\nclass Metadata {\n  @Text() key!: string\n  @Text() value!: string\n}\n\nexport const models = {\n  Seed,\n  Version,\n  Metadata,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAM,IAAI,GAAV,MAAM,IAAI,CAAA;CAGT;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,IAAI,GAAA,UAAA,CAAA;IADT;AACK,CAAA,EAAA,IAAI,CAGT;AAGD,IAAM,OAAO,GAAb,MAAM,OAAO,CAAA;CAGZ;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAiB,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,SAAA,EAAA,KAAA,CAAA,CAAA;AAChB,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,OAAO,GAAA,UAAA,CAAA;IADZ;AACK,CAAA,EAAA,OAAO,CAGZ;AAGD,IAAM,QAAQ,GAAd,MAAM,QAAQ,CAAA;CAGb;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAe,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,OAAA,EAAA,KAAA,CAAA,CAAA;AAFlB,QAAQ,GAAA,UAAA,CAAA;IADb;AACK,CAAA,EAAA,QAAQ,CAGb;AAEY,MAAA,MAAM,GAAG;IACpB,IAAI;IACJ,OAAO;IACP,QAAQ;;;;;"}

package/dist/src/ItemProperty.ts

@@ -345,6 +345,10 @@ export class ItemProperty<PropertyType> {
     return this._getSnapshot().context.seedUid
   }
 
+  get schemaUid() {
+    return this._getSnapshot().context.schemaUid
+  }
+
   get propertyName() {
     if (this._alias) {
       return this._alias

package/dist/src/allItems.ts

@@ -1,5 +1,6 @@
 import { getGlobalService } from '@/browser/services/global'
-import { writeAppState } from '@/browser/db/write'
+
+import { saveAppState } from '@/browser/db/write/saveAppState'
 
 type SaveServiceEvent = {
   modelName: string
@@ -23,7 +24,7 @@ export const saveServiceHandler = async (event: SaveServiceEvent) => {
     return
   }
 
-  await writeAppState(
+  await saveAppState(
     `snapshot__${modelName}`,
     JSON.stringify(service.getPersistedSnapshot()),
   )

package/dist/src/download.ts

@@ -17,10 +17,10 @@ import debug from 'debug'
 import { getAppDb, isAppDbReady } from '@/browser/db/sqlWasmClient'
 import { getGlobalService } from '@/browser/services'
 import { waitFor } from 'xstate'
-import { writeAppState } from '@/browser/db/write'
 import { getMetadata } from '@/browser/db/read/getMetadata'
 import { saveMetadata } from '@/browser/db/write/saveMetadata'
 import { GET_TRANSACTION_TAGS } from '@/browser/arweave/queries'
+import { saveAppState } from '@/browser/db/write/saveAppState'
 
 const logger = debug('app:files:download')
 
@@ -141,7 +141,7 @@ export const downloadAllFilesBinaryRequestHandler = async () => {
 
         excludedTransactions.add(transactionId)
 
-        await writeAppState(
+        await saveAppState(
           'excludedTransactions',
           JSON.stringify(Array.from(excludedTransactions)),
         )

package/dist/src/getPublishPayload.ts

@@ -0,0 +1,111 @@
+import { GET_SCHEMAS } from '@/browser'
+import { getItem } from '@/browser/db/read/getItem'
+import {
+  defaultAttestationData,
+  INTERNAL_DATA_TYPES,
+  VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+} from '@/shared/helpers/constants'
+import { getModelSchemas } from '@/browser/db/read/getModelSchemas'
+import { ZERO_ADDRESS } from 'thirdweb'
+import {
+  AttestationRequest,
+  SchemaEncoder,
+} from '@ethereum-attestation-service/eas-sdk'
+import { easClient, queryClient } from '@/browser/helpers'
+
+type PublishPayload = {
+  localId: string
+  seedIsRevocable: boolean
+  seedSchemaUid: string
+  seedUid: string
+  versionSchemaUid: string
+  versionUid: string
+  listOfAttestations: AttestationRequest[]
+  propertiesToUpdate: any[]
+}
+
+type MultiPublishPayload = PublishPayload[]
+
+export const getPublishPayload = async (
+  seedLocalId: string,
+): Promise<MultiPublishPayload> => {
+  const item = await getItem({ seedLocalId })
+
+  if (!item) {
+    throw new Error('Item not found')
+  }
+
+  const localId = item.seedLocalId
+  const seedIsRevocable = true
+  const seedSchemaUid = item.schemaUid
+  const seedUid = item.seedUid
+  const versionSchemaUid = VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA
+  const listOfAttestations = []
+  const propertiesToUpdate = []
+
+  const schemas = await getModelSchemas()
+
+  for (const [propertyName, itemProperty] of Object.entries(item.properties)) {
+    const foundPropertySchema = await queryClient.fetchQuery({
+      queryKey: [`getPropertySchema${propertyName}`],
+      queryFn: async () =>
+        easClient.request(GET_SCHEMAS, {
+          where: {
+            id: {
+              equals: itemProperty.schemaUid,
+            },
+          },
+        }),
+    })
+
+    if (
+      !foundPropertySchema ||
+      !foundPropertySchema.schemas ||
+      foundPropertySchema.schemas.length === 0
+    ) {
+      console.error(`Property schema not found for ${propertyName}`)
+      continue
+    }
+
+    if (!itemProperty.propertyDef) {
+      console.error(`Property definition not found for ${propertyName}`)
+      continue
+    }
+
+    const easDataType =
+      INTERNAL_DATA_TYPES[itemProperty.propertyDef.dataType].eas
+
+    const data = [
+      { name: propertyName, type: easDataType, value: itemProperty.value },
+    ]
+
+    const easSchemaDefinition = foundPropertySchema.schemas[0].schema
+
+    const dataEncoder = new SchemaEncoder(easSchemaDefinition)
+
+    const encodedData = dataEncoder.encodeData(data)
+
+    listOfAttestations.push({
+      schema: itemProperty.schemaUid!,
+      data: [
+        {
+          ...defaultAttestationData,
+          data: encodedData,
+        },
+      ],
+    })
+  }
+
+  return [
+    {
+      localId,
+      seedIsRevocable,
+      seedSchemaUid,
+      seedUid: seedUid || ZERO_ADDRESS,
+      versionUid: item.latestVersionUid || ZERO_ADDRESS,
+      versionSchemaUid,
+      listOfAttestations,
+      propertiesToUpdate,
+    },
+  ]
+}

package/dist/src/globalMachine.ts

@@ -16,6 +16,7 @@ import { addModelsToDb } from '@/browser/services/global/actors/addModelsToDb'
 import { internalMachine } from '@/browser/services/internal/internalMachine'
 import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
 import { publishMachine } from '@/browser/services/publish/publishMachine'
+import { savePublishService } from '@/browser/services/global/actors/savePublishService'
 
 const {
   UNINITIALIZED,
@@ -38,11 +39,17 @@ const globalMachine = setup({
     initialize,
     addModelsToDb,
     getSchemaForModel,
+    savePublishService,
   },
 }).createMachine({
   id: MachineIds.GLOBAL,
   initial: UNINITIALIZED,
   context: ({ input }) => input as GlobalMachineContext,
+  on: {
+    publishItemRequest: `.${PUBLISHING_ITEM}`,
+    savePublishService: `.savingPublishService`,
+    restorePublishService: `.${PUBLISHING_ITEM}`,
+  },
   states: {
     [UNINITIALIZED]: {
       on: {
@@ -73,7 +80,7 @@ const globalMachine = setup({
         displayText: 'Booting up',
         percentComplete: 5,
       },
-      tags: ['loading'],
+      tags: ['loading', 'startup'],
     },
     [INITIALIZING]: {
       on: {
@@ -130,7 +137,7 @@ const globalMachine = setup({
           displayText: 'Initializing Seed SDK',
           percentComplete: 10,
         },
-        tags: ['loading'],
+        tags: ['loading', 'startup'],
       },
     },
     [ADDING_MODELS_TO_DB]: {
@@ -148,39 +155,52 @@ const globalMachine = setup({
         meta: {
           displayText: 'Adding models to database',
         },
-        tags: ['loading'],
+        tags: ['loading', 'startup'],
       },
     },
     [INITIALIZED]: {
-      type: 'parallel',
-      on: {
-        publishItemRequest: `.${PUBLISHING_ITEM}`,
-      },
+      // type: 'parallel',
+      // on: {
+      //   publishItemRequest: `.${PUBLISHING_ITEM}`,
+      // },
       meta: {
         displayText: 'Global service ready',
         percentComplete: 40,
       },
-      tags: ['loading'],
-      states: {
-        [PUBLISHING_ITEM]: {
-          entry: [
-            assign({
-              publishItemService: ({ spawn, event }) =>
-                spawn(publishMachine, {
-                  id: 'publishService',
-                  input: {
-                    modelName: event.modelName,
-                    localId: event.seedLocalId,
-                  },
-                }),
+      tags: ['loading', 'startup'],
+      // initial: PUBLISHING_ITEM,
+    },
+    [PUBLISHING_ITEM]: {
+      target: INITIALIZED,
+      entry: [
+        assign({
+          publishItemService: ({ spawn, event }) =>
+            spawn(publishMachine, {
+              id: 'publishService',
+              input: {
+                localId: event.seedLocalId,
+              },
             }),
-          ],
-          meta: {
-            displayText: 'Publishing item',
-          },
-          tags: ['publishing'],
-        },
+        }),
+      ],
+      meta: {
+        displayText: 'Publishing item',
+      },
+      tags: ['publishing'],
+    },
+    savingPublishService: {
+      target: INITIALIZED,
+      on: {
+        savePublishServiceSuccess: INITIALIZED,
+      },
+      invoke: {
+        src: 'savePublishService',
+        input: ({ context }) => ({ context }),
+      },
+      meta: {
+        displayText: 'Saving publish service',
       },
+      tags: ['publishing'],
     },
   },
   // on: {

package/dist/src/hydrateFromDb.ts

@@ -6,6 +6,7 @@ import debug from 'debug'
 import { fs } from '@zenfs/core'
 import { metadata } from 'src/shared/seedSchema'
 import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { updateMetadata } from '@/browser/db/write/updateMetadata'
 
 const logger = debug('app:property:actors:hydrateFromDb')
 
@@ -209,6 +210,10 @@ export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
             const fileContents = await fs.promises.readFile(filePath)
             const fileHandler = new File([fileContents], refResolvedValue)
             refResolvedDisplayValue = URL.createObjectURL(fileHandler)
+            await updateMetadata({
+              localId,
+              refResolvedDisplayValue,
+            })
           }
         }
       }
@@ -222,25 +227,6 @@ export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
         propertyValueProcessed = propertyValueFromDb.split(',')
       }
 
-      if (seedLocalIdFromDb === 'sAFXuO7Uez') {
-        console.log(`[hydrateFromDb] sending updateContext with:`, {
-          type: 'updateContext',
-          localId,
-          uid,
-          propertyValue: propertyValueProcessed,
-          seedLocalId: seedLocalIdFromDb,
-          seedUid: seedUidFromDb,
-          versionLocalId: versionLocalIdFromDb,
-          versionUid: versionUidFromDb,
-          schemaUid: schemaUidFromDb,
-          refValueType,
-          localStorageDir,
-          resolvedValue: refResolvedValue,
-          resolvedDisplayValue: refResolvedDisplayValue,
-          renderValue: refResolvedDisplayValue,
-        })
-      }
-
       sendBack({
         type: 'updateContext',
         localId,

package/dist/src/index.ts

@@ -1,106 +1,21 @@
-import { EventObject, fromCallback } from 'xstate'
-import { FromCallbackInput } from '@/types/machines'
+import { setup } from 'xstate'
 import {
-  ItemPropertyValueType,
-  PropertyMachineContext,
-  SaveValueToDbEvent,
-} from '@/types/property'
-import { updateItemPropertyValue } from '@/browser/db/write/updateItemPropertyValue'
-
-export * from './saveImageSrc'
-export * from './saveRelation'
-export * from './saveItemStorage'
-
-export const analyzeInput = fromCallback<
-  EventObject,
-  FromCallbackInput<PropertyMachineContext, SaveValueToDbEvent>
->(({ sendBack, input: { context, event } }) => {
-  const {
-    localId,
-    propertyName: propertyNameRaw,
-    seedLocalId,
-    versionLocalId,
-    versionUid,
-    propertyValue: existingValue,
-    propertyRecordSchema,
-    itemModelName,
-    schemaUid,
-  } = context
-
-  let newValue: ItemPropertyValueType
-
-  if (event) {
-    newValue = event.newValue
-  }
-
-  if (existingValue === newValue) {
-    sendBack({ type: 'saveValueToDbSuccess' })
-    return
-  }
-
-  if (!propertyRecordSchema) {
-    throw new Error('Missing propertyRecordSchema')
-  }
-
-  const _analyzeInput = async (): Promise<boolean> => {
-    let propertyName = propertyNameRaw
-
-    if (
-      propertyRecordSchema.refValueType &&
-      propertyRecordSchema.refValueType !== 'ImageSrc' &&
-      propertyRecordSchema.dataType === 'Relation'
-    ) {
-      sendBack({
-        type: 'saveRelation',
-        newValue,
-      })
-      return false
-    }
-
-    if (
-      propertyRecordSchema.refValueType === 'ImageSrc' ||
-      propertyRecordSchema.dataType === 'ImageSrc'
-    ) {
-      sendBack({
-        type: 'saveImageSrc',
-        newValue,
-      })
-      return false
-    }
-
-    if (
-      propertyRecordSchema.storageType &&
-      propertyRecordSchema.storageType === 'ItemStorage'
-    ) {
-      sendBack({
-        type: 'saveItemStorage',
-        newValue,
-      })
-      return false
-    }
-
-    await updateItemPropertyValue({
-      localId: localId,
-      propertyName,
-      newValue,
-      seedLocalId,
-      versionLocalId,
-      versionUid,
-      modelName: itemModelName,
-      schemaUid,
-    })
-
-    sendBack({
-      type: 'updateContext',
-      propertyValue: newValue,
-    })
-
-    return true
-  }
-
-  _analyzeInput().then((isDone) => {
-    if (isDone) {
-      sendBack({ type: 'saveValueToDbSuccess' })
-    }
-  })
+  uploadBinaryData,
+  uploadMetadata,
+} from '@/browser/schema/file/upload/actors'
+
+export const uploadMachine = setup({
+  actors: {
+    uploadBinaryData,
+    uploadMetadata,
+  },
+}).createMachine({
+  id: 'upload',
+  initial: 'idle',
+  context: {
+    file: '',
+  },
+  states: {
+    idle: {},
+  },
 })

package/dist/src/item.ts

@@ -335,10 +335,9 @@ type UsePublishItemReturn = {
   isPublishing: boolean
 }
 
-type PublishItemProps = [
-  item: Item<any> | undefined,
-  callback?: (result: PublishItemResult) => any | undefined,
-]
+type PublishItemProps =
+  | [Item<any> | undefined]
+  | [Item<any> | undefined, (result: PublishItemResult) => any | undefined]
 
 type PublishItem = (...props: PublishItemProps) => Promise<any>
 
@@ -355,7 +354,8 @@ export const usePublishItem = (): UsePublishItemReturn => {
     console.log('Publishing item', item)
     setIsPublishing(true)
     try {
-      await item.publish()
+      // await item.publish()
+      const payload = await item.getPublishPayload()
       if (callback) {
         callback()
       }

package/dist/src/publish.ts

@@ -1,7 +1,6 @@
 import { getGlobalService } from '@/browser/services/global'
 
 type PublishItemRequestEvent = {
-  modelName?: string
   seedLocalId: string
 }
 
@@ -10,7 +9,6 @@ type PublishItemRequestHandler = (
 ) => Promise<void>
 
 export const publishItemRequestHandler: PublishItemRequestHandler = async ({
-  modelName,
   seedLocalId,
 }) => {
   const globalService = getGlobalService()
@@ -25,7 +23,6 @@ export const publishItemRequestHandler: PublishItemRequestHandler = async ({
   })
   globalService.send({
     type: 'publishItemRequest',
-    modelName,
     seedLocalId,
   })
 }

package/dist/src/saveAppState.ts

@@ -0,0 +1,19 @@
+import { getAppDb } from '@/browser'
+import { appState } from '@/shared/seedSchema'
+
+export const saveAppState = async (key: string, value: string) => {
+  const appDb = getAppDb()
+
+  await appDb
+    .insert(appState)
+    .values({
+      key,
+      value,
+    })
+    .onConflictDoUpdate({
+      target: appState.key,
+      set: {
+        value,
+      },
+    })
+}

package/dist/src/savePublishService.ts

@@ -0,0 +1,30 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, GlobalMachineContext } from '@/types/machines'
+import { saveAppState } from '@/browser/db/write/saveAppState'
+
+export const savePublishService = fromCallback<
+  EventObject,
+  FromCallbackInput<GlobalMachineContext>
+>(({ sendBack, input: { event, context } }) => {
+  const { publishItemService } = context
+
+  if (!publishItemService) {
+    sendBack({ type: 'savePublishServiceError' })
+    return
+  }
+
+  const _savePublishService = async (): Promise<boolean> => {
+    await saveAppState(
+      `snapshot__publishItemService`,
+      JSON.stringify(publishItemService.getPersistedSnapshot()),
+    )
+
+    return true
+  }
+
+  _savePublishService().then((success) => {
+    if (success) {
+      sendBack({ type: 'savePublishServiceSuccess' })
+    }
+  })
+})

package/dist/src/services.ts

@@ -14,7 +14,7 @@ import { MachineIds } from '@/browser/services/internal/constants'
 
 const logger = debug('app:react:services')
 
-const finalStrings = ['idle', 'ready', 'done', 'success']
+const finalStrings = ['idle', 'ready', 'done', 'success', 'initialized']
 
 export const getServiceName = (service: ActorRef<any, any>) => {
   let name = 'actor'
@@ -90,8 +90,17 @@ export const useService = (service: ActorRef<any, any>) => {
   const getPercentComplete = (service: ActorRef<any, any>) => {
     let percentComplete = 0
     if (service.logic.states) {
-      const stateNames = Object.keys(service.logic.states)
-      const totalStates = stateNames.length
+      const stateNames = []
+      const startupStates = []
+
+      for (const [stateName, state] of Object.entries(service.logic.states)) {
+        if (state.tags.includes('loading')) {
+          stateNames.push(stateName)
+          startupStates.push(state)
+        }
+      }
+
+      const totalStates = startupStates.length
       const value = getServiceValue(service)
       if (finalStrings.includes(value)) {
         return 0
@@ -311,7 +320,7 @@ export const useServices = () => {
       return
     }
     if (
-      getServiceValue(globalService) === 'ready' &&
+      getServiceValue(globalService) === 'initialized' &&
       getServiceValue(internalService) === 'ready'
     ) {
       const denominator = actors.length