@arcanetech/privacy-sdk-stellar 0.2.0

package/dist/state/index.js

@@ -0,0 +1,2478 @@
+// src/state/foundation/paths.ts
+var STELLAR_STATE_PATHS = {
+  privateRecords: "$.privateRecords",
+  pendingClaimsItems: "$.pendingClaims.items",
+  pendingClaimsPagination: "$.pendingClaims.pagination",
+  pendingClaimsCountByOwner: "$.pendingClaims.countByOwner",
+  registryPrivateAddresses: "$.registry.privateAddresses",
+  registryRegisteredAddresses: "$.registry.registeredAddresses",
+  registryLookups: "$.registry.lookups",
+  assets: "$.assets",
+  assetsById: "$.assets.byId",
+  assetsListOrder: "$.assets.listOrder",
+  publicBalances: "$.balances.publicByOwnerAsset",
+  poolsByContract: "$.pools.byContract",
+  poolsLeafEphemeral: "$.pools.leafEphemeralByContractAndIndex",
+  deliveriesIncomingById: "$.deliveries.incomingById",
+  deliveriesSync: "$.deliveries.syncByPrivateAddressAsset",
+  transactionsByHash: "$.transactions.byHash",
+  walletPrivateAddressScalars: "$.wallet.privateAddressScalars",
+  walletPrivateAddressRecords: "$.wallet.privateAddressRecords",
+  walletDefaultPrivateAddressNonce: "$.wallet.defaultPrivateAddressNonce"
+};
+
+// src/state/schemas/shared.ts
+import { z } from "zod";
+var pendingClaimSchema = z.object({
+  id: z.string().min(1),
+  owner: z.string().min(1),
+  asset: z.string().min(1),
+  amount: z.coerce.bigint(),
+  createdAt: z.string().min(1),
+  poolTxId: z.string().optional(),
+  commitmentHex: z.string().optional(),
+  nullifierHex: z.string().optional(),
+  futureNullifierHashHex: z.string().optional(),
+  assetHiHex: z.string().optional(),
+  assetLoHex: z.string().optional(),
+  nullifierFieldHex: z.string().optional(),
+  secretHex: z.string().optional(),
+  tempPublicKeyXHex: z.string().optional(),
+  tempPublicKeyYHex: z.string().optional(),
+  encryptedRecoveryBase64: z.string().optional(),
+  createdAtLedger: z.number().int().optional()
+});
+var paginationSchema = z.object({
+  total: z.number().int().nonnegative(),
+  page: z.number().int().positive(),
+  pageSize: z.number().int().positive(),
+  hasMore: z.boolean()
+});
+var stellarPrivateCoinNoteSchema = z.object({
+  value: z.string(),
+  nullifier: z.string(),
+  secret: z.string(),
+  commitment: z.string(),
+  asset_hi: z.string(),
+  asset_lo: z.string(),
+  application_id: z.string().optional()
+});
+var privateRecordSchema = z.object({
+  id: z.string().min(1),
+  owner: z.string().min(1),
+  asset: z.string().min(1),
+  amount: z.coerce.bigint(),
+  consumed: z.boolean(),
+  status: z.enum(["pending", "finalized", "spent"]).optional(),
+  poolContract: z.string().optional(),
+  commitmentHex: z.string().optional(),
+  nullifierHex: z.string().optional(),
+  amountDisplay: z.number().optional(),
+  deliveryId: z.number().int().optional(),
+  privateAddress: z.string().optional(),
+  txHash: z.string().optional(),
+  coinNote: stellarPrivateCoinNoteSchema.optional(),
+  depositScalarHex: z.string().optional(),
+  precommitementHex: z.string().optional()
+});
+var assetSchema = z.object({
+  id: z.number().int(),
+  assetId: z.string().min(1),
+  name: z.string().min(1),
+  logoUrl: z.string().nullable(),
+  issuerAddress: z.string().nullable(),
+  clientContract: z.string().nullable(),
+  poolContracts: z.array(z.string()),
+  poolContract: z.string().min(1),
+  mintable: z.boolean(),
+  mintAmount: z.string().nullable(),
+  decimals: z.number().int().nullable().optional()
+});
+var publicBalanceSchema = z.object({
+  owner: z.string().min(1),
+  asset: z.string().min(1),
+  balance: z.string(),
+  trustlineStatus: z.enum(["active", "inactive", "none"])
+});
+var registryLookupSchema = z.object({
+  owner: z.string().min(1),
+  status: z.enum(["registered", "unregistered"]),
+  privateAddressStpl1: z.string().optional(),
+  publicKeyXHex: z.string().optional(),
+  publicKeyYHex: z.string().optional(),
+  updatedAtLedger: z.number().int().optional(),
+  cachedAt: z.string().optional()
+});
+var walletPrivateAddressScalarSchema = z.object({
+  owner: z.string().min(1),
+  nonce: z.string().min(1),
+  scalarHex: z.string().min(1),
+  updatedAt: z.string().optional()
+});
+var walletPrivateAddressRecordSchema = z.object({
+  owner: z.string().min(1),
+  nonce: z.string().min(1),
+  privateAddress: z.string().min(1),
+  createdAt: z.number()
+});
+var poolMerkleStateSchema = z.object({
+  poolContract: z.string().min(1),
+  commitments: z.array(z.string()),
+  commitmentCount: z.number().int().nonnegative(),
+  merkleRootHex: z.string().min(1),
+  updatedAt: z.number(),
+  syncedLedger: z.number().int().optional()
+});
+var leafEphemeralSchema = z.object({
+  poolContract: z.string().min(1),
+  leafIndex: z.number().int().nonnegative(),
+  xHex: z.string().min(1),
+  yHex: z.string().min(1),
+  cachedAt: z.string().optional()
+});
+var incomingDeliverySchema = z.object({
+  id: z.number().int(),
+  privateAddress: z.string().min(1),
+  asset: z.string().min(1),
+  ciphertextBase64: z.string().min(1),
+  ephemeralKey: z.string().min(1),
+  tagBase64: z.string().min(1),
+  createdAt: z.string().min(1),
+  processed: z.boolean().optional()
+});
+var deliverySyncStateSchema = z.object({
+  privateAddress: z.string().min(1),
+  asset: z.string().min(1),
+  bloomM: z.number().int().positive(),
+  bloomK: z.number().int().positive(),
+  bloomBitsBase64: z.string().optional(),
+  lastPage: z.number().int().positive().optional(),
+  lastPolledAt: z.string().optional()
+});
+var transactionStatusSchema = z.object({
+  txHash: z.string().min(1),
+  status: z.enum(["pending", "success", "failed"]),
+  ledger: z.number().int().optional(),
+  createdAt: z.string().optional()
+});
+
+// src/state/foundation/coerce.ts
+function withoutUndefinedFields(value) {
+  const next = {};
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (fieldValue !== void 0) {
+      Reflect.set(next, key, fieldValue);
+    }
+  }
+  return next;
+}
+
+// src/state/read/normalize/assets.ts
+function normalizeAssetsCatalog(value) {
+  if (typeof value !== "object" || value === null) {
+    return { byId: {}, listOrder: [] };
+  }
+  const record = value;
+  const byIdRaw = record.byId;
+  const listOrderRaw = record.listOrder;
+  const byId = {};
+  if (typeof byIdRaw === "object" && byIdRaw !== null) {
+    for (const [key, entry] of Object.entries(byIdRaw)) {
+      const parsed = assetSchema.safeParse(entry);
+      if (parsed.success) {
+        byId[key] = withoutUndefinedFields(parsed.data);
+      }
+    }
+  }
+  const listOrder = Array.isArray(listOrderRaw) ? listOrderRaw.filter((item) => typeof item === "string") : [];
+  return { byId, listOrder };
+}
+function normalizeAsset(value) {
+  const parsed = assetSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizePublicBalance(value) {
+  const parsed = publicBalanceSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function normalizePublicBalancesFromEntries(value, owner) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    if (!Array.isArray(entry) || entry.length < 2) {
+      return;
+    }
+    const [key, balanceValue] = entry;
+    if (typeof key !== "string" || !key.startsWith(`${owner}:`)) {
+      return;
+    }
+    return normalizePublicBalance(balanceValue);
+  }).filter((balance) => balance !== void 0);
+}
+
+// src/state/read/normalize/claims.ts
+function normalizePendingClaimsState(value) {
+  if (typeof value !== "object" || value === null) {
+    return { items: [] };
+  }
+  const record = value;
+  const items = Array.isArray(record.items) ? record.items.flatMap((item) => {
+    const parsed = pendingClaimSchema.safeParse(item);
+    return parsed.success ? [withoutUndefinedFields(parsed.data)] : [];
+  }) : [];
+  const paginationResult = paginationSchema.safeParse(record.pagination);
+  if (paginationResult.success) {
+    return { items, pagination: paginationResult.data };
+  }
+  return { items };
+}
+function normalizePendingClaimsCount(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+
+// src/state/read/normalize/deliveries.ts
+function normalizeIncomingDeliveries(value) {
+  const entries = typeof value === "object" && value !== null && !Array.isArray(value) ? Object.values(value) : value;
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    const parsed = incomingDeliverySchema.safeParse(entry);
+    return parsed.success ? [withoutUndefinedFields(parsed.data)] : [];
+  });
+}
+function normalizeDeliverySyncState(value) {
+  const parsed = deliverySyncStateSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+
+// src/state/read/normalize/pool.ts
+function normalizePoolMerkleState(value) {
+  const parsed = poolMerkleStateSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizeLeafEphemeral(value) {
+  const parsed = leafEphemeralSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+
+// src/state/read/normalize/registry.ts
+function normalizeCachedPrivateAddress(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function normalizeRegistryLookup(value) {
+  const parsed = registryLookupSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizeRegistryLookupFromLegacy(input) {
+  const lookup = normalizeRegistryLookup(
+    typeof input.registered === "object" && input.registered !== null ? input.registered : void 0
+  );
+  if (lookup) {
+    return lookup;
+  }
+  if (input.registered === void 0 && input.privateAddress === void 0) {
+    return void 0;
+  }
+  const registered2 = Boolean(input.registered);
+  const privateAddressStpl1 = normalizeCachedPrivateAddress(input.privateAddress);
+  if (!registered2 && privateAddressStpl1 === void 0) {
+    return { owner: input.address, status: "unregistered" };
+  }
+  return withoutUndefinedFields({
+    owner: input.address,
+    status: registered2 ? "registered" : "unregistered",
+    ...privateAddressStpl1 === void 0 ? {} : { privateAddressStpl1 }
+  });
+}
+
+// src/state/read/normalize/records.ts
+import "zod";
+function normalizePrivateRecords(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const records = value.flatMap((item) => {
+    const parsed = privateRecordSchema.safeParse(item);
+    return parsed.success ? [normalizePrivateRecordFields(parsed.data)] : [];
+  });
+  return deduplicatePrivateRecords(records);
+}
+function normalizeTransactionStatus(value) {
+  const parsed = transactionStatusSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function privateRecordCommitmentKey(record) {
+  return (record.commitmentHex?.trim() || record.coinNote?.commitment.trim() || record.id.trim()).replace(/^0x/iu, "").toLowerCase();
+}
+function normalizePrivateRecordFields(record) {
+  const normalized = withoutUndefinedFields(record);
+  if (!normalized.privateAddress && normalized.owner.trim().startsWith("stpl")) {
+    return { ...normalized, privateAddress: normalized.owner.trim() };
+  }
+  return normalized;
+}
+function preferPrivateRecord(current, incoming, key) {
+  if (privateRecordIdKey(incoming) === key) {
+    return incoming;
+  }
+  if (privateRecordIdKey(current) === key) {
+    return current;
+  }
+  return incoming;
+}
+function privateRecordIdKey(record) {
+  return record.id.trim().replace(/^0x/iu, "").toLowerCase();
+}
+function deduplicatePrivateRecords(records) {
+  const byCommitment = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const key = privateRecordCommitmentKey(record);
+    const current = byCommitment.get(key);
+    byCommitment.set(key, current ? preferPrivateRecord(current, record, key) : record);
+  }
+  return [...byCommitment.values()];
+}
+
+// src/state/read/normalize/wallet.ts
+function normalizeWalletPrivateAddressScalar(value) {
+  const parsed = walletPrivateAddressScalarSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizeWalletPrivateAddressRecord(value) {
+  const parsed = walletPrivateAddressRecordSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizeWalletDefaultPrivateAddressNonce(value) {
+  return typeof value === "string" ? value.trim() || void 0 : void 0;
+}
+
+// src/state/read/snapshot.ts
+function readSnapshotObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function resolveSdkSnapshot(value) {
+  const record = readSnapshotObject(value);
+  if (!record) {
+    return void 0;
+  }
+  const branch = readSnapshotObject(record.privacySdkState);
+  return branch ?? record;
+}
+function readWalletSnapshot(value) {
+  const sdk = resolveSdkSnapshot(value);
+  if (!sdk) {
+    return void 0;
+  }
+  return readSnapshotObject(sdk.wallet);
+}
+function readWalletMap(value, key) {
+  const wallet = readWalletSnapshot(value);
+  if (!wallet) {
+    return void 0;
+  }
+  if (key === "privateAddressScalars") {
+    return readSnapshotObject(wallet.privateAddressScalars);
+  }
+  if (key === "privateAddressRecords") {
+    return readSnapshotObject(wallet.privateAddressRecords);
+  }
+  return readSnapshotObject(wallet.defaultPrivateAddressNonce);
+}
+function readRecordValue(record, key) {
+  for (const [entryKey, entryValue] of Object.entries(record)) {
+    if (entryKey === key) {
+      return entryValue;
+    }
+  }
+  return void 0;
+}
+function ownerNonceKey(owner, nonce) {
+  return `${owner.trim()}:${nonce.trim()}`;
+}
+function readPrivateRecordsFromStateSnapshot(state) {
+  const sdk = resolveSdkSnapshot(state);
+  if (!sdk) {
+    return [];
+  }
+  return normalizePrivateRecords(sdk.privateRecords);
+}
+function readWalletPrivateAddressScalarFromStateSnapshot(input) {
+  const owner = input.owner.trim();
+  const nonce = input.nonce.trim();
+  if (!owner || !nonce) {
+    return void 0;
+  }
+  const scalars = readWalletMap(input.state, "privateAddressScalars");
+  if (!scalars) {
+    return void 0;
+  }
+  const value = scalars[ownerNonceKey(owner, nonce)];
+  if (typeof value === "string") {
+    const scalarHex = value.trim();
+    return scalarHex ? { owner, nonce, scalarHex } : void 0;
+  }
+  return normalizeWalletPrivateAddressScalar(value);
+}
+function readWalletPrivateAddressRecordFromStateSnapshot(input) {
+  const owner = input.owner.trim();
+  const nonce = input.nonce.trim();
+  if (!owner || !nonce) {
+    return void 0;
+  }
+  const records = readWalletMap(input.state, "privateAddressRecords");
+  if (!records) {
+    return void 0;
+  }
+  return normalizeWalletPrivateAddressRecord(records[ownerNonceKey(owner, nonce)]);
+}
+function readWalletDefaultPrivateAddressNonceFromStateSnapshot(input) {
+  const owner = input.owner.trim();
+  if (!owner) {
+    return void 0;
+  }
+  const defaults = readWalletMap(input.state, "defaultPrivateAddressNonce");
+  if (!defaults) {
+    return void 0;
+  }
+  return normalizeWalletDefaultPrivateAddressNonce(readRecordValue(defaults, owner));
+}
+function listWalletPrivateAddressScalarsForOwnerFromStateSnapshot(input) {
+  const owner = input.owner.trim();
+  if (!owner) {
+    return [];
+  }
+  const scalars = readWalletMap(input.state, "privateAddressScalars");
+  if (!scalars) {
+    return [];
+  }
+  const prefix = `${owner}:`;
+  return Object.keys(scalars).flatMap((key) => {
+    if (!key.startsWith(prefix)) {
+      return [];
+    }
+    const nonce = key.slice(prefix.length).trim();
+    if (!nonce) {
+      return [];
+    }
+    const entry = readWalletPrivateAddressScalarFromStateSnapshot({
+      state: input.state,
+      owner,
+      nonce
+    });
+    return entry ? [entry] : [];
+  });
+}
+function listWalletPrivateAddressRecordsForOwnerFromStateSnapshot(input) {
+  const owner = input.owner.trim();
+  if (!owner) {
+    return [];
+  }
+  const records = readWalletMap(input.state, "privateAddressRecords");
+  if (!records) {
+    return [];
+  }
+  const prefix = `${owner}:`;
+  return Object.keys(records).flatMap((key) => {
+    if (!key.startsWith(prefix)) {
+      return [];
+    }
+    const nonce = key.slice(prefix.length).trim();
+    if (!nonce) {
+      return [];
+    }
+    const entry = readWalletPrivateAddressRecordFromStateSnapshot({
+      state: input.state,
+      owner,
+      nonce
+    });
+    return entry ? [entry] : [];
+  });
+}
+
+// src/state/filters/register-schemas.ts
+import { registerArrayFilterItemSchema } from "@arcanetech/privacy-sdk-core/state";
+
+// src/state/filters/ops.ts
+var stellarArrayFilterSchemaKeys = {
+  privateRecord: "privateRecord",
+  pendingClaim: "pendingClaim"
+};
+function rejectPrivateRecordsByIds(ids) {
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.privateRecords,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.privateRecord,
+    rejectWhen: {
+      op: "fieldIn",
+      field: "id",
+      values: ids
+    }
+  };
+}
+function rejectConsumedPrivateRecords() {
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.privateRecords,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.privateRecord,
+    rejectWhen: {
+      op: "fieldEquals",
+      field: "consumed",
+      value: true
+    }
+  };
+}
+function rejectPendingClaimsByOwner(owner) {
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
+    rejectWhen: {
+      op: "fieldEquals",
+      field: "owner",
+      value: owner
+    }
+  };
+}
+function rejectPendingClaimsByIds(ids) {
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
+    rejectWhen: {
+      op: "fieldIn",
+      field: "id",
+      values: ids
+    }
+  };
+}
+function rejectPendingClaimsByOwnerAndAsset(input) {
+  const matches = [];
+  if (input.owner !== void 0) {
+    matches.push({
+      op: "fieldEquals",
+      field: "owner",
+      value: input.owner
+    });
+  }
+  if (input.asset !== void 0) {
+    matches.push({
+      op: "fieldEquals",
+      field: "asset",
+      value: input.asset
+    });
+  }
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
+    rejectWhen: {
+      op: "and",
+      matches
+    }
+  };
+}
+
+// src/state/filters/register-schemas.ts
+var registered = false;
+function registerStellarArrayFilterSchemas() {
+  if (registered) {
+    return;
+  }
+  registerArrayFilterItemSchema(
+    stellarArrayFilterSchemaKeys.privateRecord,
+    privateRecordSchema
+  );
+  registerArrayFilterItemSchema(
+    stellarArrayFilterSchemaKeys.pendingClaim,
+    pendingClaimSchema
+  );
+  registered = true;
+}
+
+// src/state/bridge/call-types.ts
+import "@arcanetech/privacy-sdk-core/state";
+var stellarStateCallTypes = {
+  pendingClaims: "pendingClaims",
+  clearPendingClaims: "clearPendingClaims",
+  readPendingClaims: "readPendingClaims",
+  replacePendingClaimsPage: "replacePendingClaimsPage",
+  upsertPendingClaims: "upsertPendingClaims",
+  removePendingClaims: "removePendingClaims",
+  setPendingClaimsCount: "setPendingClaimsCount",
+  readPendingClaimsCount: "readPendingClaimsCount",
+  readStellarAddressRegistered: "readStellarAddressRegistered",
+  readCachedPrivateAddress: "readCachedPrivateAddress",
+  readRegistryLookup: "readRegistryLookup",
+  saveRegisteredPrivateAddress: "saveRegisteredPrivateAddress",
+  saveRegistryLookup: "saveRegistryLookup",
+  invalidateRegisteredAddress: "invalidateRegisteredAddress",
+  invalidateRegistryLookup: "invalidateRegistryLookup",
+  readAssetsCatalog: "readAssetsCatalog",
+  readAsset: "readAsset",
+  replaceAssets: "replaceAssets",
+  upsertAssets: "upsertAssets",
+  readPublicBalance: "readPublicBalance",
+  readPublicBalances: "readPublicBalances",
+  setPublicBalance: "setPublicBalance",
+  setPublicBalances: "setPublicBalances",
+  readPoolMerkleState: "readPoolMerkleState",
+  setPoolMerkleState: "setPoolMerkleState",
+  readLeafEphemeral: "readLeafEphemeral",
+  setLeafEphemeral: "setLeafEphemeral",
+  listPrivateRecords: "listPrivateRecords",
+  savePrivateRecords: "savePrivateRecords",
+  replacePrivateRecords: "replacePrivateRecords",
+  upsertPrivateRecords: "upsertPrivateRecords",
+  pruneConsumedPrivateRecords: "pruneConsumedPrivateRecords",
+  readIncomingDeliveries: "readIncomingDeliveries",
+  upsertIncomingDeliveries: "upsertIncomingDeliveries",
+  readDeliverySyncState: "readDeliverySyncState",
+  setDeliverySyncState: "setDeliverySyncState",
+  readTransactionStatus: "readTransactionStatus",
+  setTransactionStatus: "setTransactionStatus",
+  clearTransactionStatus: "clearTransactionStatus",
+  saveWalletPrivateAddressScalar: "saveWalletPrivateAddressScalar",
+  readWalletPrivateAddressScalar: "readWalletPrivateAddressScalar",
+  saveWalletPrivateAddressRecord: "saveWalletPrivateAddressRecord",
+  readWalletPrivateAddressRecord: "readWalletPrivateAddressRecord",
+  setWalletDefaultPrivateAddressNonce: "setWalletDefaultPrivateAddressNonce",
+  readWalletDefaultPrivateAddressNonce: "readWalletDefaultPrivateAddressNonce",
+  deleteWalletPrivateAddressScalar: "deleteWalletPrivateAddressScalar"
+};
+
+// src/state/schemas/assets/catalog.ts
+import { z as z3 } from "zod";
+var readAssetsCatalogSchema = z3.object({
+  type: z3.literal(stellarStateCallTypes.readAssetsCatalog)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "primitiveGet",
+      jsonPath: STELLAR_STATE_PATHS.assets
+    }
+  ]
+}));
+var readAssetSchema = z3.object({
+  type: z3.literal(stellarStateCallTypes.readAsset),
+  assetId: z3.string().min(1)
+}).transform(({ type, assetId }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.assetsById,
+      key: assetId
+    }
+  ]
+}));
+var replaceAssetsSchema = z3.object({
+  type: z3.literal(stellarStateCallTypes.replaceAssets),
+  assets: z3.array(assetSchema)
+}).transform(({ type, assets }) => {
+  const byId = {};
+  const listOrder = [];
+  for (const asset of assets) {
+    Reflect.set(byId, asset.assetId, withoutUndefinedFields(asset));
+    listOrder.push(asset.assetId);
+  }
+  return {
+    type,
+    operations: [
+      {
+        opType: "primitiveSet",
+        jsonPath: STELLAR_STATE_PATHS.assets,
+        value: { byId, listOrder }
+      }
+    ]
+  };
+});
+var upsertAssetsSchema = z3.object({
+  type: z3.literal(stellarStateCallTypes.upsertAssets),
+  assets: z3.array(assetSchema)
+}).transform(({ type, assets }) => ({
+  type,
+  operations: assets.map((asset) => ({
+    opType: "recordSet",
+    jsonPath: STELLAR_STATE_PATHS.assetsById,
+    key: asset.assetId,
+    value: asset
+  }))
+}));
+
+// src/state/definitions/assets.ts
+var stellarAssetsStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readAssetsCatalog,
+    mode: "read",
+    schema: readAssetsCatalogSchema
+  },
+  {
+    type: stellarStateCallTypes.readAsset,
+    mode: "read",
+    schema: readAssetSchema
+  },
+  {
+    type: stellarStateCallTypes.replaceAssets,
+    mode: "write",
+    schema: replaceAssetsSchema
+  },
+  {
+    type: stellarStateCallTypes.upsertAssets,
+    mode: "write",
+    schema: upsertAssetsSchema
+  }
+];
+
+// src/state/schemas/assets/balances.ts
+import { z as z4 } from "zod";
+
+// src/state/foundation/keys.ts
+function ownerAssetKey(owner, asset) {
+  return `${owner}:${asset}`;
+}
+function readRecordValue2(record, key) {
+  if (!Object.hasOwn(record, key)) {
+    return void 0;
+  }
+  return Reflect.get(record, key);
+}
+function poolLeafKey(poolContract, leafIndex) {
+  return `${poolContract}:${leafIndex}`;
+}
+function privateAddressAssetKey(privateAddress, asset) {
+  return `${privateAddress}:${asset}`;
+}
+function walletOwnerNonceKey(owner, nonce) {
+  return `${owner}:${nonce}`;
+}
+
+// src/state/schemas/assets/balances.ts
+var readPublicBalanceSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.readPublicBalance),
+  owner: z4.string().min(1),
+  asset: z4.string().min(1)
+}).transform(({ type, owner, asset }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.publicBalances,
+      key: ownerAssetKey(owner, asset)
+    }
+  ]
+}));
+var readPublicBalancesSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.readPublicBalances),
+  owner: z4.string().min(1)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordEntries",
+      jsonPath: STELLAR_STATE_PATHS.publicBalances
+    }
+  ]
+}));
+var setPublicBalanceSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.setPublicBalance),
+  balance: publicBalanceSchema
+}).transform(({ type, balance }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.publicBalances,
+      key: ownerAssetKey(balance.owner, balance.asset),
+      value: balance
+    }
+  ]
+}));
+var setPublicBalancesSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.setPublicBalances),
+  owner: z4.string().min(1),
+  balances: z4.array(publicBalanceSchema)
+}).transform(({ type, owner, balances }) => ({
+  type,
+  operations: balances.map((balance) => ({
+    opType: "recordSet",
+    jsonPath: STELLAR_STATE_PATHS.publicBalances,
+    key: ownerAssetKey(owner, balance.asset),
+    value: { ...balance, owner }
+  }))
+}));
+
+// src/state/definitions/balances.ts
+var stellarBalancesStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readPublicBalance,
+    mode: "read",
+    schema: readPublicBalanceSchema
+  },
+  {
+    type: stellarStateCallTypes.readPublicBalances,
+    mode: "read",
+    schema: readPublicBalancesSchema
+  },
+  {
+    type: stellarStateCallTypes.setPublicBalance,
+    mode: "write",
+    schema: setPublicBalanceSchema
+  },
+  {
+    type: stellarStateCallTypes.setPublicBalances,
+    mode: "write",
+    schema: setPublicBalancesSchema
+  }
+];
+
+// src/state/schemas/claims/write.ts
+import { z as z5 } from "zod";
+var pendingClaimsWriteSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.pendingClaims),
+  claims: z5.array(pendingClaimSchema),
+  paginationInfo: paginationSchema
+}).transform(({ type, claims, paginationInfo }) => ({
+  type,
+  operations: [
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+      items: claims
+    },
+    {
+      opType: "primitiveSet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsPagination,
+      value: paginationInfo
+    }
+  ]
+}));
+var clearPendingClaimsSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.clearPendingClaims),
+  owner: z5.string().optional(),
+  asset: z5.string().optional()
+}).transform(({ type, owner, asset }) => {
+  if (owner === void 0 && asset === void 0) {
+    return {
+      type,
+      operations: [
+        {
+          opType: "arrayClean",
+          jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems
+        }
+      ]
+    };
+  }
+  return {
+    type,
+    operations: [rejectPendingClaimsByOwnerAndAsset({ owner, asset })]
+  };
+});
+var readPendingClaimsSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.readPendingClaims)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "primitiveGet",
+      jsonPath: "$.pendingClaims"
+    }
+  ]
+}));
+
+// src/state/schemas/claims/page.ts
+import { z as z6 } from "zod";
+var pendingClaimBridgeItemSchema = pendingClaimSchema;
+var replacePendingClaimsPageSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.replacePendingClaimsPage),
+  owner: z6.string().min(1),
+  claims: z6.array(pendingClaimBridgeItemSchema),
+  paginationInfo: z6.object({
+    total: z6.number().int().nonnegative(),
+    page: z6.number().int().positive(),
+    pageSize: z6.number().int().positive(),
+    hasMore: z6.boolean()
+  }),
+  count: z6.number().int().nonnegative().optional()
+}).transform(({ type, owner, claims, paginationInfo, count }) => ({
+  type,
+  operations: [
+    rejectPendingClaimsByOwner(owner),
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+      items: claims
+    },
+    {
+      opType: "primitiveSet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsPagination,
+      value: paginationInfo
+    },
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
+      key: owner,
+      value: count ?? paginationInfo.total
+    }
+  ]
+}));
+var upsertPendingClaimsSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.upsertPendingClaims),
+  claims: z6.array(pendingClaimBridgeItemSchema)
+}).transform(({ type, claims }) => ({
+  type,
+  operations: [
+    rejectPendingClaimsByIds(claims.map((claim) => claim.id)),
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+      items: claims
+    }
+  ]
+}));
+var removePendingClaimsSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.removePendingClaims),
+  ids: z6.array(z6.string().min(1))
+}).transform(({ type, ids }) => ({
+  type,
+  operations: [rejectPendingClaimsByIds(ids)]
+}));
+var readPendingClaimsCountSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.readPendingClaimsCount),
+  owner: z6.string().min(1)
+}).transform(({ type, owner }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
+      key: owner
+    }
+  ]
+}));
+var setPendingClaimsCountSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.setPendingClaimsCount),
+  owner: z6.string().min(1),
+  count: z6.number().int().nonnegative()
+}).transform(({ type, owner, count }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
+      key: owner,
+      value: count
+    }
+  ]
+}));
+
+// src/state/definitions/claims.ts
+var stellarClaimsStateDefinitions = [
+  {
+    type: stellarStateCallTypes.pendingClaims,
+    mode: "write",
+    schema: pendingClaimsWriteSchema
+  },
+  {
+    type: stellarStateCallTypes.clearPendingClaims,
+    mode: "write",
+    schema: clearPendingClaimsSchema
+  },
+  {
+    type: stellarStateCallTypes.readPendingClaims,
+    mode: "read",
+    schema: readPendingClaimsSchema
+  },
+  {
+    type: stellarStateCallTypes.replacePendingClaimsPage,
+    mode: "write",
+    schema: replacePendingClaimsPageSchema
+  },
+  {
+    type: stellarStateCallTypes.upsertPendingClaims,
+    mode: "write",
+    schema: upsertPendingClaimsSchema
+  },
+  {
+    type: stellarStateCallTypes.removePendingClaims,
+    mode: "write",
+    schema: removePendingClaimsSchema
+  },
+  {
+    type: stellarStateCallTypes.readPendingClaimsCount,
+    mode: "read",
+    schema: readPendingClaimsCountSchema
+  },
+  {
+    type: stellarStateCallTypes.setPendingClaimsCount,
+    mode: "write",
+    schema: setPendingClaimsCountSchema
+  }
+];
+
+// src/state/schemas/claims/deliveries.ts
+import { z as z7 } from "zod";
+var readIncomingDeliveriesSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.readIncomingDeliveries)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "primitiveGet",
+      jsonPath: STELLAR_STATE_PATHS.deliveriesIncomingById
+    }
+  ]
+}));
+var upsertIncomingDeliveriesSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.upsertIncomingDeliveries),
+  deliveries: z7.array(incomingDeliverySchema)
+}).transform(({ type, deliveries }) => ({
+  type,
+  operations: deliveries.map((delivery) => ({
+    opType: "recordSet",
+    jsonPath: STELLAR_STATE_PATHS.deliveriesIncomingById,
+    key: String(delivery.id),
+    value: delivery
+  }))
+}));
+var readDeliverySyncStateSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.readDeliverySyncState),
+  privateAddress: z7.string().min(1),
+  asset: z7.string().min(1)
+}).transform(({ type, privateAddress, asset }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.deliveriesSync,
+      key: privateAddressAssetKey(privateAddress, asset)
+    }
+  ]
+}));
+var setDeliverySyncStateSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.setDeliverySyncState),
+  syncState: deliverySyncStateSchema
+}).transform(({ type, syncState }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.deliveriesSync,
+      key: privateAddressAssetKey(syncState.privateAddress, syncState.asset),
+      value: syncState
+    }
+  ]
+}));
+
+// src/state/definitions/deliveries.ts
+var stellarDeliveriesStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readIncomingDeliveries,
+    mode: "read",
+    schema: readIncomingDeliveriesSchema
+  },
+  {
+    type: stellarStateCallTypes.upsertIncomingDeliveries,
+    mode: "write",
+    schema: upsertIncomingDeliveriesSchema
+  },
+  {
+    type: stellarStateCallTypes.readDeliverySyncState,
+    mode: "read",
+    schema: readDeliverySyncStateSchema
+  },
+  {
+    type: stellarStateCallTypes.setDeliverySyncState,
+    mode: "write",
+    schema: setDeliverySyncStateSchema
+  }
+];
+
+// src/state/schemas/pool/merkle.ts
+import { z as z8 } from "zod";
+var readPoolMerkleStateSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.readPoolMerkleState),
+  poolContract: z8.string().min(1)
+}).transform(({ type, poolContract }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.poolsByContract,
+      key: poolContract
+    }
+  ]
+}));
+var setPoolMerkleStateSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.setPoolMerkleState),
+  state: poolMerkleStateSchema
+}).transform(({ type, state }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.poolsByContract,
+      key: state.poolContract,
+      value: state
+    }
+  ]
+}));
+var readLeafEphemeralSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.readLeafEphemeral),
+  poolContract: z8.string().min(1),
+  leafIndex: z8.number().int().nonnegative()
+}).transform(({ type, poolContract, leafIndex }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.poolsLeafEphemeral,
+      key: poolLeafKey(poolContract, leafIndex)
+    }
+  ]
+}));
+var setLeafEphemeralSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.setLeafEphemeral),
+  ephemeral: leafEphemeralSchema
+}).transform(({ type, ephemeral }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.poolsLeafEphemeral,
+      key: poolLeafKey(ephemeral.poolContract, ephemeral.leafIndex),
+      value: ephemeral
+    }
+  ]
+}));
+
+// src/state/definitions/pool.ts
+var stellarPoolStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readPoolMerkleState,
+    mode: "read",
+    schema: readPoolMerkleStateSchema
+  },
+  {
+    type: stellarStateCallTypes.setPoolMerkleState,
+    mode: "write",
+    schema: setPoolMerkleStateSchema
+  },
+  {
+    type: stellarStateCallTypes.readLeafEphemeral,
+    mode: "read",
+    schema: readLeafEphemeralSchema
+  },
+  {
+    type: stellarStateCallTypes.setLeafEphemeral,
+    mode: "write",
+    schema: setLeafEphemeralSchema
+  }
+];
+
+// src/state/schemas/records/private.ts
+import { z as z9 } from "zod";
+var listPrivateRecordsSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.listPrivateRecords)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "primitiveGet",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords
+    }
+  ]
+}));
+var savePrivateRecordsSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.savePrivateRecords),
+  records: z9.array(privateRecordSchema)
+}).transform(({ type, records }) => ({
+  type,
+  operations: [
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords,
+      items: records
+    }
+  ]
+}));
+var replacePrivateRecordsSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.replacePrivateRecords),
+  records: z9.array(privateRecordSchema)
+}).transform(({ type, records }) => ({
+  type,
+  operations: [
+    {
+      opType: "arrayClean",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords
+    },
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords,
+      items: records
+    }
+  ]
+}));
+var pruneConsumedPrivateRecordsSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.pruneConsumedPrivateRecords)
+}).transform(({ type }) => ({
+  type,
+  operations: [rejectConsumedPrivateRecords()]
+}));
+
+// src/state/schemas/records/transactions.ts
+import { z as z10 } from "zod";
+var upsertPrivateRecordsSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.upsertPrivateRecords),
+  records: z10.array(privateRecordSchema)
+}).transform(({ type, records }) => ({
+  type,
+  operations: [
+    rejectPrivateRecordsByIds(records.map((record) => record.id)),
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords,
+      items: records
+    }
+  ]
+}));
+var readTransactionStatusSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.readTransactionStatus),
+  txHash: z10.string().min(1)
+}).transform(({ type, txHash }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.transactionsByHash,
+      key: txHash
+    }
+  ]
+}));
+var setTransactionStatusSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.setTransactionStatus),
+  status: transactionStatusSchema
+}).transform(({ type, status }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.transactionsByHash,
+      key: status.txHash,
+      value: status
+    }
+  ]
+}));
+var clearTransactionStatusSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.clearTransactionStatus),
+  txHash: z10.string().min(1)
+}).transform(({ type, txHash }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.transactionsByHash,
+      key: txHash
+    }
+  ]
+}));
+
+// src/state/definitions/records.ts
+var stellarRecordsStateDefinitions = [
+  {
+    type: stellarStateCallTypes.listPrivateRecords,
+    mode: "read",
+    schema: listPrivateRecordsSchema
+  },
+  {
+    type: stellarStateCallTypes.savePrivateRecords,
+    mode: "write",
+    schema: savePrivateRecordsSchema
+  },
+  {
+    type: stellarStateCallTypes.replacePrivateRecords,
+    mode: "write",
+    schema: replacePrivateRecordsSchema
+  },
+  {
+    type: stellarStateCallTypes.upsertPrivateRecords,
+    mode: "write",
+    schema: upsertPrivateRecordsSchema
+  },
+  {
+    type: stellarStateCallTypes.pruneConsumedPrivateRecords,
+    mode: "write",
+    schema: pruneConsumedPrivateRecordsSchema
+  }
+];
+
+// src/state/schemas/registry/lookup.ts
+import { z as z11 } from "zod";
+var readStellarAddressRegisteredSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.readStellarAddressRegistered),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+      key: address
+    }
+  ]
+}));
+var readCachedPrivateAddressSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.readCachedPrivateAddress),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+      key: address
+    }
+  ]
+}));
+var saveRegisteredPrivateAddressSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.saveRegisteredPrivateAddress),
+  address: z11.string().min(1),
+  privateAddress: z11.string().min(1),
+  registered: z11.boolean()
+}).transform(({ type, address, privateAddress, registered: registered2 }) => {
+  const lookup = registryLookupSchema.parse({
+    owner: address,
+    status: registered2 ? "registered" : "unregistered",
+    privateAddressStpl1: registered2 ? privateAddress : void 0,
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    type,
+    operations: [
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+        key: address,
+        value: privateAddress
+      },
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+        key: address,
+        value: registered2
+      },
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryLookups,
+        key: address,
+        value: lookup
+      }
+    ]
+  };
+});
+var invalidateRegisteredAddressSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.invalidateRegisteredAddress),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+      key: address
+    },
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+      key: address
+    },
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryLookups,
+      key: address
+    }
+  ]
+}));
+var readRegistryLookupSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.readRegistryLookup),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.registryLookups,
+      key: address
+    }
+  ]
+}));
+var saveRegistryLookupSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.saveRegistryLookup),
+  lookup: registryLookupSchema
+}).transform(({ type, lookup }) => {
+  const operations = [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.registryLookups,
+      key: lookup.owner,
+      value: lookup
+    }
+  ];
+  if (lookup.status === "registered" && lookup.privateAddressStpl1) {
+    operations.push(
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+        key: lookup.owner,
+        value: lookup.privateAddressStpl1
+      },
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+        key: lookup.owner,
+        value: true
+      }
+    );
+  } else {
+    operations.push({
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+      key: lookup.owner,
+      value: false
+    });
+  }
+  return { type, operations };
+});
+var invalidateRegistryLookupSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.invalidateRegistryLookup),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryLookups,
+      key: address
+    },
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+      key: address
+    },
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+      key: address
+    }
+  ]
+}));
+
+// src/state/definitions/registry.ts
+var stellarRegistryStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readStellarAddressRegistered,
+    mode: "read",
+    schema: readStellarAddressRegisteredSchema
+  },
+  {
+    type: stellarStateCallTypes.readCachedPrivateAddress,
+    mode: "read",
+    schema: readCachedPrivateAddressSchema
+  },
+  {
+    type: stellarStateCallTypes.readRegistryLookup,
+    mode: "read",
+    schema: readRegistryLookupSchema
+  },
+  {
+    type: stellarStateCallTypes.saveRegisteredPrivateAddress,
+    mode: "write",
+    schema: saveRegisteredPrivateAddressSchema
+  },
+  {
+    type: stellarStateCallTypes.saveRegistryLookup,
+    mode: "write",
+    schema: saveRegistryLookupSchema
+  },
+  {
+    type: stellarStateCallTypes.invalidateRegisteredAddress,
+    mode: "write",
+    schema: invalidateRegisteredAddressSchema
+  },
+  {
+    type: stellarStateCallTypes.invalidateRegistryLookup,
+    mode: "write",
+    schema: invalidateRegistryLookupSchema
+  }
+];
+
+// src/state/definitions/transactions.ts
+var stellarTransactionStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readTransactionStatus,
+    mode: "read",
+    schema: readTransactionStatusSchema
+  },
+  {
+    type: stellarStateCallTypes.setTransactionStatus,
+    mode: "write",
+    schema: setTransactionStatusSchema
+  },
+  {
+    type: stellarStateCallTypes.clearTransactionStatus,
+    mode: "write",
+    schema: clearTransactionStatusSchema
+  }
+];
+
+// src/state/schemas/wallet/scalar.ts
+import { z as z12 } from "zod";
+var saveWalletPrivateAddressScalarSchema = z12.object({
+  type: z12.literal(stellarStateCallTypes.saveWalletPrivateAddressScalar),
+  scalar: walletPrivateAddressScalarSchema
+}).transform(({ type, scalar }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressScalars,
+      key: walletOwnerNonceKey(scalar.owner, scalar.nonce),
+      value: scalar
+    }
+  ]
+}));
+var readWalletPrivateAddressScalarSchema = z12.object({
+  type: z12.literal(stellarStateCallTypes.readWalletPrivateAddressScalar),
+  owner: z12.string().min(1),
+  nonce: z12.string().min(1)
+}).transform(({ type, owner, nonce }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressScalars,
+      key: walletOwnerNonceKey(owner, nonce)
+    }
+  ]
+}));
+
+// src/state/schemas/wallet/private-address.ts
+import { z as z13 } from "zod";
+var saveWalletPrivateAddressRecordSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.saveWalletPrivateAddressRecord),
+  record: walletPrivateAddressRecordSchema
+}).transform(({ type, record }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressRecords,
+      key: walletOwnerNonceKey(record.owner, record.nonce),
+      value: record
+    }
+  ]
+}));
+var readWalletPrivateAddressRecordSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.readWalletPrivateAddressRecord),
+  owner: z13.string().min(1),
+  nonce: z13.string().min(1)
+}).transform(({ type, owner, nonce }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressRecords,
+      key: walletOwnerNonceKey(owner, nonce)
+    }
+  ]
+}));
+var setWalletDefaultPrivateAddressNonceSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.setWalletDefaultPrivateAddressNonce),
+  owner: z13.string().min(1),
+  nonce: z13.string().min(1)
+}).transform(({ type, owner, nonce }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.walletDefaultPrivateAddressNonce,
+      key: owner,
+      value: nonce
+    }
+  ]
+}));
+var readWalletDefaultPrivateAddressNonceSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.readWalletDefaultPrivateAddressNonce),
+  owner: z13.string().min(1)
+}).transform(({ type, owner }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.walletDefaultPrivateAddressNonce,
+      key: owner
+    }
+  ]
+}));
+var deleteWalletPrivateAddressScalarSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.deleteWalletPrivateAddressScalar),
+  owner: z13.string().min(1),
+  nonce: z13.string().min(1)
+}).transform(({ type, owner, nonce }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressScalars,
+      key: walletOwnerNonceKey(owner, nonce)
+    }
+  ]
+}));
+
+// src/state/definitions/wallet.ts
+var stellarWalletStateDefinitions = [
+  {
+    type: stellarStateCallTypes.saveWalletPrivateAddressScalar,
+    mode: "write",
+    schema: saveWalletPrivateAddressScalarSchema
+  },
+  {
+    type: stellarStateCallTypes.readWalletPrivateAddressScalar,
+    mode: "read",
+    schema: readWalletPrivateAddressScalarSchema
+  },
+  {
+    type: stellarStateCallTypes.saveWalletPrivateAddressRecord,
+    mode: "write",
+    schema: saveWalletPrivateAddressRecordSchema
+  },
+  {
+    type: stellarStateCallTypes.readWalletPrivateAddressRecord,
+    mode: "read",
+    schema: readWalletPrivateAddressRecordSchema
+  },
+  {
+    type: stellarStateCallTypes.setWalletDefaultPrivateAddressNonce,
+    mode: "write",
+    schema: setWalletDefaultPrivateAddressNonceSchema
+  },
+  {
+    type: stellarStateCallTypes.readWalletDefaultPrivateAddressNonce,
+    mode: "read",
+    schema: readWalletDefaultPrivateAddressNonceSchema
+  },
+  {
+    type: stellarStateCallTypes.deleteWalletPrivateAddressScalar,
+    mode: "write",
+    schema: deleteWalletPrivateAddressScalarSchema
+  }
+];
+
+// src/state/definitions/index.ts
+registerStellarArrayFilterSchemas();
+var stellarStateDefinitions = [
+  ...stellarClaimsStateDefinitions,
+  ...stellarRegistryStateDefinitions,
+  ...stellarAssetsStateDefinitions,
+  ...stellarBalancesStateDefinitions,
+  ...stellarPoolStateDefinitions,
+  ...stellarRecordsStateDefinitions,
+  ...stellarDeliveriesStateDefinitions,
+  ...stellarWalletStateDefinitions,
+  ...stellarTransactionStateDefinitions
+];
+
+// src/state/service/base.ts
+import {
+  createStateBridge
+} from "@arcanetech/privacy-sdk-core/state";
+var StellarStateServiceBase = class {
+  bridge;
+  constructor(adapter) {
+    this.bridge = createStateBridge(adapter);
+    this.bridge.init(stellarStateDefinitions);
+  }
+};
+
+// src/state/service/assets/balance-methods.ts
+function createPublicBalanceMethods(context) {
+  const { bridge } = context;
+  return {
+    async getPublicBalance(input) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readPublicBalance,
+        owner: input.owner,
+        asset: input.asset
+      });
+      return normalizePublicBalance(value);
+    },
+    async getPublicBalances(owner) {
+      const entries = await bridge.read({
+        type: stellarStateCallTypes.readPublicBalances,
+        owner
+      });
+      return normalizePublicBalancesFromEntries(entries, owner);
+    },
+    setPublicBalance(balance) {
+      return bridge.write({
+        type: stellarStateCallTypes.setPublicBalance,
+        balance
+      });
+    },
+    setPublicBalances(input) {
+      return bridge.write({
+        type: stellarStateCallTypes.setPublicBalances,
+        owner: input.owner,
+        balances: input.balances
+      });
+    }
+  };
+}
+
+// src/state/service/assets/upsert-methods.ts
+function createAssetsUpsertMethods(_context, deps) {
+  return {
+    async upsertAssets(assets) {
+      if (assets.length === 0) {
+        return;
+      }
+      const catalog = await deps.getAssetsCatalog();
+      const byId = { ...catalog.byId };
+      const listOrder = [...catalog.listOrder];
+      for (const asset of assets) {
+        byId[asset.assetId] = asset;
+        if (!listOrder.includes(asset.assetId)) {
+          listOrder.push(asset.assetId);
+        }
+      }
+      const merged = listOrder.map((assetId) => readRecordValue2(byId, assetId)).filter((asset) => asset !== void 0);
+      await deps.replaceAssets(merged);
+    }
+  };
+}
+
+// src/state/service/assets/catalog-methods.ts
+function createAssetsCatalogMethods(context) {
+  const { bridge } = context;
+  async function getAssetsCatalog() {
+    const value = await bridge.read({
+      type: stellarStateCallTypes.readAssetsCatalog
+    });
+    return normalizeAssetsCatalog(value);
+  }
+  function replaceAssets(assets) {
+    return bridge.write({
+      type: stellarStateCallTypes.replaceAssets,
+      assets
+    });
+  }
+  const coreMethods = {
+    getAssetsCatalog,
+    async getAsset(assetId) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readAsset,
+        assetId
+      });
+      return normalizeAsset(value);
+    },
+    async getAssets() {
+      const catalog = await getAssetsCatalog();
+      return catalog.listOrder.map((assetId) => readRecordValue2(catalog.byId, assetId)).filter((asset) => asset !== void 0);
+    },
+    async getAssetsForPool(poolContract) {
+      const assets = await coreMethods.getAssets();
+      return assets.filter((asset) => asset.poolContracts.includes(poolContract));
+    },
+    replaceAssets
+  };
+  return {
+    ...coreMethods,
+    ...createAssetsUpsertMethods(context, {
+      getAssetsCatalog,
+      replaceAssets
+    })
+  };
+}
+
+// src/state/service/assets/index.ts
+function createAssetsService(context) {
+  return {
+    ...createAssetsCatalogMethods(context),
+    ...createPublicBalanceMethods(context)
+  };
+}
+
+// src/state/service/claims/read-methods.ts
+function createClaimsReadMethods(context) {
+  const { bridge } = context;
+  async function getPendingClaims(filter = {}) {
+    const value = await bridge.read({
+      type: stellarStateCallTypes.readPendingClaims
+    });
+    const state = normalizePendingClaimsState(value);
+    const items = state.items.filter((claim) => {
+      if (filter.owner !== void 0 && claim.owner !== filter.owner) {
+        return false;
+      }
+      if (filter.asset !== void 0 && claim.asset !== filter.asset) {
+        return false;
+      }
+      return true;
+    });
+    if (state.pagination !== void 0) {
+      return { items, pagination: state.pagination };
+    }
+    return { items };
+  }
+  return {
+    getPendingClaims,
+    async getPendingClaimsCount(owner) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readPendingClaimsCount,
+        owner
+      });
+      const count = normalizePendingClaimsCount(value);
+      if (count !== void 0) {
+        return count;
+      }
+      const claims = await getPendingClaims({ owner });
+      return claims.items.length;
+    }
+  };
+}
+
+// src/state/service/claims/write-methods.ts
+function appendPendingClaims(bridge, claims, paginationInfo) {
+  return bridge.write({
+    type: stellarStateCallTypes.pendingClaims,
+    claims,
+    paginationInfo
+  });
+}
+function replacePendingClaimsPage(bridge, input) {
+  return bridge.write({
+    type: stellarStateCallTypes.replacePendingClaimsPage,
+    owner: input.owner,
+    claims: input.claims,
+    paginationInfo: input.paginationInfo,
+    ...input.count === void 0 ? {} : { count: input.count }
+  });
+}
+function upsertPendingClaims(bridge, claims) {
+  return bridge.write({
+    type: stellarStateCallTypes.upsertPendingClaims,
+    claims
+  });
+}
+function removePendingClaims(bridge, ids) {
+  return bridge.write({
+    type: stellarStateCallTypes.removePendingClaims,
+    ids
+  });
+}
+function clearPendingClaims(bridge, input = {}) {
+  return bridge.write({
+    type: stellarStateCallTypes.clearPendingClaims,
+    ...input.owner === void 0 ? {} : { owner: input.owner },
+    ...input.asset === void 0 ? {} : { asset: input.asset }
+  });
+}
+function setPendingClaimsCount(bridge, owner, count) {
+  return bridge.write({
+    type: stellarStateCallTypes.setPendingClaimsCount,
+    owner,
+    count
+  });
+}
+function createClaimsWriteMethods(context) {
+  const { bridge } = context;
+  return {
+    appendPendingClaims: (claims, paginationInfo) => appendPendingClaims(bridge, claims, paginationInfo),
+    replacePendingClaimsPage: (input) => replacePendingClaimsPage(bridge, input),
+    upsertPendingClaims: (claims) => upsertPendingClaims(bridge, claims),
+    removePendingClaims: (ids) => removePendingClaims(bridge, ids),
+    clearPendingClaims: (input = {}) => clearPendingClaims(bridge, input),
+    setPendingClaimsCount: (owner, count) => setPendingClaimsCount(bridge, owner, count)
+  };
+}
+
+// src/state/service/claims/index.ts
+function createClaimsService(context) {
+  return {
+    ...createClaimsWriteMethods(context),
+    ...createClaimsReadMethods(context)
+  };
+}
+
+// src/state/service/deliveries/incoming-methods.ts
+function createIncomingDeliveryMethods(context) {
+  const { bridge } = context;
+  async function getIncomingDeliveries(filter) {
+    const values = await bridge.read({
+      type: stellarStateCallTypes.readIncomingDeliveries
+    });
+    const deliveries = normalizeIncomingDeliveries(values);
+    return deliveries.filter((delivery) => {
+      if (delivery.privateAddress !== filter.privateAddress) {
+        return false;
+      }
+      if (filter.asset !== void 0 && delivery.asset !== filter.asset) {
+        return false;
+      }
+      if (!filter.includeProcessed && delivery.processed) {
+        return false;
+      }
+      return true;
+    });
+  }
+  function upsertIncomingDeliveries(deliveries) {
+    return bridge.write({
+      type: stellarStateCallTypes.upsertIncomingDeliveries,
+      deliveries
+    });
+  }
+  return {
+    getIncomingDeliveries,
+    upsertIncomingDeliveries,
+    async markDeliveryProcessed(id) {
+      const deliveries = await bridge.read({
+        type: stellarStateCallTypes.readIncomingDeliveries
+      });
+      const match = normalizeIncomingDeliveries(deliveries).find(
+        (delivery) => delivery.id === id
+      );
+      if (!match) {
+        return;
+      }
+      await upsertIncomingDeliveries([{ ...match, processed: true }]);
+    }
+  };
+}
+
+// src/state/service/deliveries/sync-methods.ts
+function createDeliverySyncMethods(context) {
+  const { bridge } = context;
+  return {
+    async getDeliverySyncState(input) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readDeliverySyncState,
+        privateAddress: input.privateAddress,
+        asset: input.asset
+      });
+      return normalizeDeliverySyncState(value);
+    },
+    setDeliverySyncState(syncState) {
+      return bridge.write({
+        type: stellarStateCallTypes.setDeliverySyncState,
+        syncState
+      });
+    }
+  };
+}
+
+// src/state/service/deliveries/index.ts
+function createDeliveriesService(context) {
+  return {
+    ...createIncomingDeliveryMethods(context),
+    ...createDeliverySyncMethods(context)
+  };
+}
+
+// src/state/service/pool/ephemeral.ts
+function isMissingStatePathError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes("Record path not found:") || error.message.includes("JSONPath segment not found:");
+}
+function createPoolEphemeralService(context) {
+  const { bridge } = context;
+  return {
+    async getLeafEphemeral(input) {
+      try {
+        const value = await bridge.read({
+          type: stellarStateCallTypes.readLeafEphemeral,
+          poolContract: input.poolContract,
+          leafIndex: input.leafIndex
+        });
+        return normalizeLeafEphemeral(value);
+      } catch (error) {
+        if (isMissingStatePathError(error)) {
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    setLeafEphemeral(ephemeral) {
+      return bridge.write({
+        type: stellarStateCallTypes.setLeafEphemeral,
+        ephemeral
+      });
+    }
+  };
+}
+
+// src/state/service/pool/merkle.ts
+function isMissingStatePathError2(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes("Record path not found:") || error.message.includes("JSONPath segment not found:");
+}
+function createPoolMerkleService(context) {
+  const { bridge } = context;
+  return {
+    async getPoolMerkleState(poolContract) {
+      try {
+        const value = await bridge.read({
+          type: stellarStateCallTypes.readPoolMerkleState,
+          poolContract
+        });
+        return normalizePoolMerkleState(value);
+      } catch (error) {
+        if (isMissingStatePathError2(error)) {
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    setPoolMerkleState(state) {
+      return bridge.write({
+        type: stellarStateCallTypes.setPoolMerkleState,
+        state
+      });
+    },
+    async appendPoolCommitments(input) {
+      const current = await this.getPoolMerkleState(input.poolContract);
+      const mergedCommitments = [...current?.commitments ?? [], ...input.commitments];
+      await this.setPoolMerkleState(
+        withoutUndefinedFields({
+          poolContract: input.poolContract,
+          commitments: mergedCommitments,
+          commitmentCount: mergedCommitments.length,
+          merkleRootHex: input.merkleRootHex,
+          updatedAt: Date.now(),
+          syncedLedger: input.syncedLedger ?? current?.syncedLedger
+        })
+      );
+    }
+  };
+}
+
+// src/state/service/records/private-record-upsert.ts
+function privateCoinNotesEqual(left, right) {
+  if (left === void 0 || right === void 0) {
+    return left === right;
+  }
+  return left.value === right.value && left.nullifier === right.nullifier && left.secret === right.secret && left.commitment === right.commitment && left.asset_hi === right.asset_hi && left.asset_lo === right.asset_lo && left.application_id === right.application_id;
+}
+function privateRecordCoreFieldsEqual(left, right) {
+  return left.id === right.id && left.owner === right.owner && left.asset === right.asset && left.amount === right.amount && left.consumed === right.consumed && left.status === right.status && left.poolContract === right.poolContract && left.amountDisplay === right.amountDisplay;
+}
+function privateRecordChainFieldsEqual(left, right) {
+  return left.commitmentHex === right.commitmentHex && left.nullifierHex === right.nullifierHex && left.deliveryId === right.deliveryId && left.privateAddress === right.privateAddress && left.txHash === right.txHash;
+}
+function privateRecordSecretFieldsEqual(left, right) {
+  return left.depositScalarHex === right.depositScalarHex && left.precommitementHex === right.precommitementHex && privateCoinNotesEqual(left.coinNote, right.coinNote);
+}
+function privateRecordsEqual(left, right) {
+  return privateRecordCoreFieldsEqual(left, right) && privateRecordChainFieldsEqual(left, right) && privateRecordSecretFieldsEqual(left, right);
+}
+function privateRecordArraysEqual(left, right) {
+  return left.length === right.length && left.every((record, index) => {
+    const rightRecord = right.at(index);
+    return rightRecord !== void 0 && privateRecordsEqual(record, rightRecord);
+  });
+}
+function mergePrivateRecords(current, records) {
+  const ids = new Set(records.map((record) => record.id));
+  return [...current.filter((record) => !ids.has(record.id)), ...records];
+}
+
+// src/state/service/records/private-methods.ts
+async function readPrivateRecords(bridge) {
+  const value = await bridge.read({
+    type: stellarStateCallTypes.listPrivateRecords
+  });
+  return normalizePrivateRecords(value);
+}
+function writeReplacePrivateRecords(bridge, records) {
+  return bridge.write({
+    type: stellarStateCallTypes.replacePrivateRecords,
+    records
+  });
+}
+async function readAvailablePrivateRecords(bridge, filter) {
+  const records = await readPrivateRecords(bridge);
+  return records.filter((record) => matchesPrivateRecordFilter(record, filter, false));
+}
+async function applyPrivateRecordsStatus(bridge, records, status) {
+  const current = await readPrivateRecords(bridge);
+  const ids = new Set(records.map((record) => record.id));
+  const next = current.map(
+    (record) => ids.has(record.id) ? {
+      ...record,
+      status,
+      consumed: status === "spent" ? true : record.consumed
+    } : record
+  );
+  await writeReplacePrivateRecords(bridge, next);
+}
+function aggregatePrivateAssetRows(records, owner) {
+  const available = records.filter(
+    (record) => record.owner === owner && !record.consumed && record.status !== "spent"
+  );
+  const byAsset = /* @__PURE__ */ new Map();
+  for (const record of available) {
+    const existing = byAsset.get(record.asset);
+    const amountDisplay = record.amountDisplay ?? Number(record.amount);
+    if (existing) {
+      existing.totalAmount += record.amount;
+      existing.totalAmountDisplay += amountDisplay;
+    } else {
+      byAsset.set(record.asset, {
+        assetId: record.asset,
+        poolContract: record.poolContract ?? "",
+        totalAmount: record.amount,
+        totalAmountDisplay: amountDisplay
+      });
+    }
+  }
+  return [...byAsset.values()].toSorted(
+    (left, right) => left.assetId.localeCompare(right.assetId)
+  );
+}
+function pruneConsumedPrivateRecords(bridge) {
+  return bridge.write({
+    type: stellarStateCallTypes.pruneConsumedPrivateRecords
+  });
+}
+function savePrivateRecords(bridge, records) {
+  return bridge.write({
+    type: stellarStateCallTypes.savePrivateRecords,
+    records
+  });
+}
+async function upsertPrivateRecords(bridge, records) {
+  if (records.length === 0) {
+    return;
+  }
+  const current = await readPrivateRecords(bridge);
+  const next = mergePrivateRecords(current, records);
+  if (privateRecordArraysEqual(current, next)) {
+    return;
+  }
+  return bridge.write({
+    type: stellarStateCallTypes.upsertPrivateRecords,
+    records
+  });
+}
+async function readPrivateBalance(bridge, input) {
+  const records = await readAvailablePrivateRecords(bridge, {
+    owner: input.owner,
+    asset: input.asset
+  });
+  return records.reduce((total, record) => total + record.amount, 0n);
+}
+async function readPrivateAssetRows(bridge, owner) {
+  const records = await readPrivateRecords(bridge);
+  return aggregatePrivateAssetRows(records, owner);
+}
+function createPrivateRecordMethods(context) {
+  const { bridge } = context;
+  return {
+    pruneConsumedPrivateRecords: () => pruneConsumedPrivateRecords(bridge),
+    getPrivateRecords: () => readPrivateRecords(bridge),
+    getAvailablePrivateRecords: (filter) => readAvailablePrivateRecords(bridge, filter),
+    listPrivateRecords: (filter) => readAvailablePrivateRecords(bridge, filter),
+    savePrivateRecords: (records) => savePrivateRecords(bridge, records),
+    upsertPrivateRecords: (records) => upsertPrivateRecords(bridge, records),
+    markPrivateRecordsUsed: (records) => applyPrivateRecordsStatus(bridge, records, "spent"),
+    markPrivateRecordsStatus: (records, status) => applyPrivateRecordsStatus(bridge, records, status),
+    getPrivateBalance: (input) => readPrivateBalance(bridge, input),
+    getPrivateAssetRows: (owner) => readPrivateAssetRows(bridge, owner)
+  };
+}
+function matchesPrivateRecordFilter(record, filter, includeConsumed) {
+  if (filter.owner !== void 0 && record.owner !== filter.owner) {
+    return false;
+  }
+  if (filter.privateAddress !== void 0 && record.privateAddress !== filter.privateAddress) {
+    return false;
+  }
+  if (filter.owner === void 0 && filter.privateAddress === void 0) {
+    return false;
+  }
+  if (filter.asset !== void 0 && record.asset !== filter.asset) {
+    return false;
+  }
+  if (!includeConsumed && (record.consumed || record.status === "spent")) {
+    return false;
+  }
+  return true;
+}
+
+// src/state/service/records/transaction-methods.ts
+function createTransactionRecordMethods(context) {
+  const { bridge } = context;
+  return {
+    async getTransactionStatus(txHash) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readTransactionStatus,
+        txHash
+      });
+      return normalizeTransactionStatus(value);
+    },
+    setTransactionStatus(status) {
+      return bridge.write({
+        type: stellarStateCallTypes.setTransactionStatus,
+        status
+      });
+    },
+    clearTransactionStatus(txHash) {
+      return bridge.write({
+        type: stellarStateCallTypes.clearTransactionStatus,
+        txHash
+      });
+    }
+  };
+}
+
+// src/state/service/records/index.ts
+function createRecordsService(context) {
+  return {
+    ...createPrivateRecordMethods(context),
+    ...createTransactionRecordMethods(context)
+  };
+}
+
+// src/state/service/registry/lookup-read.ts
+async function readRegistryLookup(bridge, address) {
+  try {
+    const value = await bridge.read({
+      type: stellarStateCallTypes.readRegistryLookup,
+      address
+    });
+    const lookup = normalizeRegistryLookup(value);
+    if (lookup) {
+      return lookup;
+    }
+  } catch {
+  }
+  let registered2;
+  let privateAddress;
+  try {
+    registered2 = await bridge.read({
+      type: stellarStateCallTypes.readStellarAddressRegistered,
+      address
+    });
+  } catch {
+    registered2 = void 0;
+  }
+  try {
+    privateAddress = await bridge.read({
+      type: stellarStateCallTypes.readCachedPrivateAddress,
+      address
+    });
+  } catch {
+    privateAddress = void 0;
+  }
+  return normalizeRegistryLookupFromLegacy({
+    address,
+    registered: registered2,
+    privateAddress
+  });
+}
+async function readCachedPrivateAddress(bridge, address) {
+  const lookup = await readRegistryLookup(bridge, address);
+  if (lookup?.privateAddressStpl1) {
+    return lookup.privateAddressStpl1;
+  }
+  const value = await bridge.read({
+    type: stellarStateCallTypes.readCachedPrivateAddress,
+    address
+  });
+  return normalizeCachedPrivateAddress(value);
+}
+function createRegistryLookupReadMethods(context) {
+  const { bridge } = context;
+  return {
+    getRegistryLookup: (address) => readRegistryLookup(bridge, address),
+    async isStellarAddressRegistered(address) {
+      const lookup = await readRegistryLookup(bridge, address);
+      if (lookup === void 0) {
+        return void 0;
+      }
+      return lookup.status === "registered";
+    },
+    getCachedPrivateAddress: (address) => readCachedPrivateAddress(bridge, address)
+  };
+}
+
+// src/state/service/registry/lookup-write.ts
+function createRegistryLookupWriteMethods(context) {
+  const { bridge } = context;
+  async function invalidateRegistryLookup(address) {
+    return bridge.write({
+      type: stellarStateCallTypes.invalidateRegistryLookup,
+      address
+    });
+  }
+  return {
+    saveRegistryLookup(lookup) {
+      return bridge.write({
+        type: stellarStateCallTypes.saveRegistryLookup,
+        lookup
+      });
+    },
+    saveRegisteredPrivateAddress(input) {
+      return bridge.write({
+        type: stellarStateCallTypes.saveRegisteredPrivateAddress,
+        address: input.address,
+        privateAddress: input.privateAddress,
+        registered: input.registered
+      });
+    },
+    invalidateRegistryLookup,
+    invalidateRegisteredAddress(address) {
+      return invalidateRegistryLookup(address);
+    }
+  };
+}
+
+// src/state/service/registry/lookup.ts
+function createRegistryLookupService(context) {
+  return {
+    ...createRegistryLookupReadMethods(context),
+    ...createRegistryLookupWriteMethods(context)
+  };
+}
+
+// src/state/service/registry/wallet-record-methods.ts
+function createWalletRecordMethods(context) {
+  const { bridge } = context;
+  return {
+    async getWalletPrivateAddressRecord(input) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readWalletPrivateAddressRecord,
+        owner: input.owner,
+        nonce: input.nonce
+      });
+      return normalizeWalletPrivateAddressRecord(value);
+    },
+    saveWalletPrivateAddressRecord(record) {
+      return bridge.write({
+        type: stellarStateCallTypes.saveWalletPrivateAddressRecord,
+        record
+      });
+    },
+    async getWalletDefaultPrivateAddressNonce(owner) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readWalletDefaultPrivateAddressNonce,
+        owner
+      });
+      return normalizeWalletDefaultPrivateAddressNonce(value);
+    },
+    setWalletDefaultPrivateAddressNonce(input) {
+      return bridge.write({
+        type: stellarStateCallTypes.setWalletDefaultPrivateAddressNonce,
+        owner: input.owner,
+        nonce: input.nonce
+      });
+    }
+  };
+}
+
+// src/state/service/registry/wallet-scalar-methods.ts
+function createWalletScalarMethods(context) {
+  const { bridge } = context;
+  return {
+    async getWalletPrivateAddressScalar(input) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readWalletPrivateAddressScalar,
+        owner: input.owner,
+        nonce: input.nonce
+      });
+      return normalizeWalletPrivateAddressScalar(value);
+    },
+    saveWalletPrivateAddressScalar(scalar) {
+      return bridge.write({
+        type: stellarStateCallTypes.saveWalletPrivateAddressScalar,
+        scalar
+      });
+    },
+    deleteWalletPrivateAddressScalar(input) {
+      return bridge.write({
+        type: stellarStateCallTypes.deleteWalletPrivateAddressScalar,
+        owner: input.owner,
+        nonce: input.nonce
+      });
+    }
+  };
+}
+
+// src/state/service/registry/wallet-address.ts
+function createWalletAddressService(context) {
+  return {
+    ...createWalletScalarMethods(context),
+    ...createWalletRecordMethods(context)
+  };
+}
+
+// src/state/service/compose.ts
+function composeStellarStateService(adapter) {
+  const base = new StellarStateServiceBase(adapter);
+  return {
+    bridge: base.bridge,
+    ...createAssetsService(base),
+    ...createRegistryLookupService(base),
+    ...createWalletAddressService(base),
+    ...createPoolMerkleService(base),
+    ...createPoolEphemeralService(base),
+    ...createClaimsService(base),
+    ...createDeliveriesService(base),
+    ...createRecordsService(base)
+  };
+}
+
+// src/state/service/index.ts
+function createStellarStateService(adapter) {
+  return composeStellarStateService(adapter);
+}
+function createStellarStorageAdapterFromState(state) {
+  return {
+    listPrivateRecords: (filter) => state.listPrivateRecords(filter),
+    savePrivateRecords: (records) => state.savePrivateRecords(records),
+    markPrivateRecordsUsed: (records) => state.markPrivateRecordsUsed(records)
+  };
+}
+export {
+  STELLAR_STATE_PATHS,
+  assetSchema,
+  createStellarStateService,
+  createStellarStorageAdapterFromState,
+  deliverySyncStateSchema,
+  incomingDeliverySchema,
+  leafEphemeralSchema,
+  listWalletPrivateAddressRecordsForOwnerFromStateSnapshot,
+  listWalletPrivateAddressScalarsForOwnerFromStateSnapshot,
+  paginationSchema,
+  pendingClaimSchema,
+  poolMerkleStateSchema,
+  privateRecordSchema,
+  publicBalanceSchema,
+  readPrivateRecordsFromStateSnapshot,
+  readWalletDefaultPrivateAddressNonceFromStateSnapshot,
+  readWalletPrivateAddressRecordFromStateSnapshot,
+  readWalletPrivateAddressScalarFromStateSnapshot,
+  registryLookupSchema,
+  stellarStateCallTypes,
+  stellarStateDefinitions,
+  transactionStatusSchema
+};
+//# sourceMappingURL=index.js.map