@ixo/decision-oracle 0.0.0-stage → 0.2.0

package/dist/lib/ixo/blocksync/types.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Shapes returned by the blocksync GraphQL reads (the CHAIN plane of a claim, §4) — as Zod, the
+ * engine-client posture (lib/engine/types.ts): responses are PARSED at the fetch site (index.ts),
+ * never cast. Money logic (payment.ts) and the cron cursor read these fields, so a blocksync
+ * schema drift must fail loudly there instead of corrupting an amount silently. LOOSE objects
+ * throughout — blocksync may add fields freely — but every field the kit READS is typed, with
+ * nullables explicit. jsonb columns (`payments`, `paymentsStatus`, `service`, `linkedResource`)
+ * are author/chain-marshalled and can be ragged, so their inner fields tolerate ABSENCE
+ * (`nullish`), not just null — proto3 JSON omits zero-value enums, and DID-document entries are
+ * whatever the author anchored.
+ */
+import { z } from "zod";
+import type { TraceContext } from "../../tracing.js";
+/** A chain coin as blocksync serializes it — integer base-unit string amounts (SDK `CoinSDKType`). */
+export declare const Coin: z.ZodObject<{
+    denom: z.ZodString;
+    amount: z.ZodString;
+}, z.core.$loose>;
+export type Coin = z.infer<typeof Coin>;
+/** The on-chain claim row: metadata only — the body lives with the claim bot (§4). */
+export declare const ClaimNode: z.ZodObject<{
+    claimId: z.ZodString;
+    collectionId: z.ZodString;
+    agentDid: z.ZodNullable<z.ZodString>;
+    agentAddress: z.ZodNullable<z.ZodString>;
+    schemaType: z.ZodNullable<z.ZodString>;
+    amount: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        denom: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$loose>>>;
+    useIntent: z.ZodNullable<z.ZodBoolean>;
+    paymentsStatus: z.ZodNullable<z.ZodObject<{
+        submission: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        evaluation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        approval: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        rejection: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>;
+    submissionDate: z.ZodNullable<z.ZodString>;
+    collection: z.ZodNullable<z.ZodObject<{
+        protocol: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>>;
+    evaluationByClaimId: z.ZodNullable<z.ZodObject<{
+        status: z.ZodNullable<z.ZodNumber>;
+        oracle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type ClaimNode = z.infer<typeof ClaimNode>;
+/**
+ * One payment lane of a collection's on-chain `Payments`, verbatim jsonb — the SNAKE_CASE
+ * internals (`timeout_ns`, `contract_1155_payment`) ride loose; only the two fields the money
+ * gates read are typed.
+ */
+export declare const CollectionPayment: z.ZodObject<{
+    amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        denom: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$loose>>>>;
+    account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type CollectionPayment = z.infer<typeof CollectionPayment>;
+/** The four payment lanes x/claims splits (payments.go:65) — evaluation and approval carry ours. */
+export declare const CollectionPayments: z.ZodObject<{
+    submission: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            denom: z.ZodString;
+            amount: z.ZodString;
+        }, z.core.$loose>>>>;
+        account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>>;
+    evaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            denom: z.ZodString;
+            amount: z.ZodString;
+        }, z.core.$loose>>>>;
+        account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>>;
+    approval: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            denom: z.ZodString;
+            amount: z.ZodString;
+        }, z.core.$loose>>>>;
+        account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>>;
+    rejection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            denom: z.ZodString;
+            amount: z.ZodString;
+        }, z.core.$loose>>>>;
+        account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type CollectionPayments = z.infer<typeof CollectionPayments>;
+/** The on-chain collection: `admin` is the entity account, `entity`/`protocol` resolve the bot. */
+export declare const CollectionNode: z.ZodObject<{
+    id: z.ZodString;
+    admin: z.ZodNullable<z.ZodString>;
+    protocol: z.ZodNullable<z.ZodString>;
+    entity: z.ZodNullable<z.ZodString>;
+    startDate: z.ZodNullable<z.ZodString>;
+    endDate: z.ZodNullable<z.ZodString>;
+    payments: z.ZodNullable<z.ZodObject<{
+        submission: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                denom: z.ZodString;
+                amount: z.ZodString;
+            }, z.core.$loose>>>>;
+            account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+        evaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                denom: z.ZodString;
+                amount: z.ZodString;
+            }, z.core.$loose>>>>;
+            account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+        approval: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                denom: z.ZodString;
+                amount: z.ZodString;
+            }, z.core.$loose>>>>;
+            account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+        rejection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                denom: z.ZodString;
+                amount: z.ZodString;
+            }, z.core.$loose>>>>;
+            account: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type CollectionNode = z.infer<typeof CollectionNode>;
+/**
+ * One service entry on an entity/iid DID document — author-written jsonb, so entries CAN be
+ * ragged (the cellnode resolver already guarded `type` with `?.` before this schema existed);
+ * a matcher skips what it cannot read, and one ragged entry must never fail the whole pull.
+ */
+export declare const IidService: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    serviceEndpoint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type IidService = z.infer<typeof IidService>;
+/**
+ * One LinkedResource on an entity DID document — `proof` is the content sha256 (rubric §C.2).
+ * Same ragged-jsonb posture as `IidService`; nothing in the kit reads these fields today.
+ */
+export declare const LinkedResource: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    mediaType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    serviceEndpoint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    proof: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    encrypted: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    right: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type LinkedResource = z.infer<typeof LinkedResource>;
+/**
+ * An agent's `MsgClaimIntent`, reduced to the two things a speed fact needs: WHEN it was filed and
+ * WHICH transaction says so. The intent's own terms are not read here — the claim already carries
+ * them verbatim (`useIntent`/`amount`), so this read is a clock and a citation, nothing more.
+ */
+export interface ClaimIntent {
+    /** The transaction's time, as blocksync spells it (UTC, usually with no zone designator). */
+    time: string;
+    /** The tx hash — what a reason string cites so a person can look the commitment up. */
+    transactionHash: string;
+}
+/** A claim as seen by the cron scan — just enough to enqueue and advance the cursor (§7). */
+export declare const ScannedClaim: z.ZodObject<{
+    claimId: z.ZodString;
+    submissionDate: z.ZodNullable<z.ZodString>;
+    agentAddress: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export type ScannedClaim = z.infer<typeof ScannedClaim>;
+/** What blocksync queries need from the caller. */
+export interface BlocksyncDeps {
+    config: {
+        BLOCKSYNC_GRAPHQL_URL: string;
+    };
+    trace: TraceContext;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/ixo/blocksync/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/lib/ixo/blocksync/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,sGAAsG;AACtG,eAAO,MAAM,IAAI;;;iBAA2D,CAAC;AAC7E,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,sFAAsF;AACtF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;iBAK5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,oGAAoG;AACpG,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,mGAAmG;AACnG,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;iBAIrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;iBASzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,6FAA6F;AAC7F,eAAO,MAAM,YAAY;;;;iBAKvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,mDAAmD;AACnD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE;QAAE,qBAAqB,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE,YAAY,CAAC;CACrB"}

package/dist/lib/ixo/blocksync/types.js

@@ -0,0 +1,108 @@
+/**
+ * Shapes returned by the blocksync GraphQL reads (the CHAIN plane of a claim, §4) — as Zod, the
+ * engine-client posture (lib/engine/types.ts): responses are PARSED at the fetch site (index.ts),
+ * never cast. Money logic (payment.ts) and the cron cursor read these fields, so a blocksync
+ * schema drift must fail loudly there instead of corrupting an amount silently. LOOSE objects
+ * throughout — blocksync may add fields freely — but every field the kit READS is typed, with
+ * nullables explicit. jsonb columns (`payments`, `paymentsStatus`, `service`, `linkedResource`)
+ * are author/chain-marshalled and can be ragged, so their inner fields tolerate ABSENCE
+ * (`nullish`), not just null — proto3 JSON omits zero-value enums, and DID-document entries are
+ * whatever the author anchored.
+ */
+import { z } from "zod";
+/** A chain coin as blocksync serializes it — integer base-unit string amounts (SDK `CoinSDKType`). */
+export const Coin = z.looseObject({ denom: z.string(), amount: z.string() });
+/** The on-chain claim row: metadata only — the body lives with the claim bot (§4). */
+export const ClaimNode = z.looseObject({
+    claimId: z.string(),
+    collectionId: z.string(),
+    agentDid: z.string().nullable(),
+    agentAddress: z.string().nullable(),
+    schemaType: z.string().nullable(),
+    /** The claim's payout coins — blocksync returns `null` (not `[]`) when the claim carries none. */
+    amount: z.array(Coin).nullable(),
+    /** True when the claim was submitted against an intent: the payout is escrow-governed (§payment). */
+    useIntent: z.boolean().nullable(),
+    /** Payment lifecycle per lane, as enum NAMES ("NO_PAYMENT" | "GUARANTEED" | "PAID" | …). */
+    paymentsStatus: z
+        .looseObject({
+        submission: z.string().nullish(),
+        evaluation: z.string().nullish(),
+        approval: z.string().nullish(),
+        rejection: z.string().nullish(),
+    })
+        .nullable(),
+    submissionDate: z.string().nullable(),
+    collection: z.looseObject({ protocol: z.string().nullable() }).nullable(),
+    /**
+     * The claim's CURRENT evaluation, or null. Only `status` and `oracle` are read (chain-write.ts's
+     * already-landed guard); everything else rides loose — the old cast typed `reason` as a string
+     * and `amount` as a non-null array, neither of which the chain's proto (uint32 reason, nullable
+     * coins) actually promises.
+     */
+    evaluationByClaimId: z
+        .looseObject({ status: z.number().nullable(), oracle: z.string().nullish() })
+        .nullable(),
+});
+/**
+ * One payment lane of a collection's on-chain `Payments`, verbatim jsonb — the SNAKE_CASE
+ * internals (`timeout_ns`, `contract_1155_payment`) ride loose; only the two fields the money
+ * gates read are typed.
+ */
+export const CollectionPayment = z.looseObject({
+    /** What the payer owes on this lane. EMPTY is legal on chain and skips the payment silently. */
+    amount: z.array(Coin).nullish(),
+    /** The account the money comes OUT of — what a funds check reads a balance from. */
+    account: z.string().nullish(),
+});
+/** The four payment lanes x/claims splits (payments.go:65) — evaluation and approval carry ours. */
+export const CollectionPayments = z.looseObject({
+    submission: CollectionPayment.nullish(),
+    evaluation: CollectionPayment.nullish(),
+    approval: CollectionPayment.nullish(),
+    rejection: CollectionPayment.nullish(),
+});
+/** The on-chain collection: `admin` is the entity account, `entity`/`protocol` resolve the bot. */
+export const CollectionNode = z.looseObject({
+    id: z.string(),
+    admin: z.string().nullable(),
+    protocol: z.string().nullable(),
+    entity: z.string().nullable(),
+    /** The collection window — the FactSet's `ctx.collection.*` (missing bound = unbounded). */
+    startDate: z.string().nullable(),
+    endDate: z.string().nullable(),
+    /** Live payment config — null only on rows blocksync hasn't indexed payments for. */
+    payments: CollectionPayments.nullable(),
+});
+/**
+ * One service entry on an entity/iid DID document — author-written jsonb, so entries CAN be
+ * ragged (the cellnode resolver already guarded `type` with `?.` before this schema existed);
+ * a matcher skips what it cannot read, and one ragged entry must never fail the whole pull.
+ */
+export const IidService = z.looseObject({
+    id: z.string().nullish(),
+    type: z.string().nullish(),
+    serviceEndpoint: z.string().nullish(),
+});
+/**
+ * One LinkedResource on an entity DID document — `proof` is the content sha256 (rubric §C.2).
+ * Same ragged-jsonb posture as `IidService`; nothing in the kit reads these fields today.
+ */
+export const LinkedResource = z.looseObject({
+    id: z.string().nullish(),
+    type: z.string().nullish(),
+    description: z.string().nullish(),
+    mediaType: z.string().nullish(),
+    serviceEndpoint: z.string().nullish(),
+    proof: z.string().nullish(),
+    encrypted: z.string().nullish(),
+    right: z.string().nullish(),
+});
+/** A claim as seen by the cron scan — just enough to enqueue and advance the cursor (§7). */
+export const ScannedClaim = z.looseObject({
+    claimId: z.string(),
+    submissionDate: z.string().nullable(),
+    /** The submitter wallet — what the cron matches on to skip a lane's own claims (cron/collection.ts). */
+    agentAddress: z.string().nullable(),
+});
+//# sourceMappingURL=types.js.map

package/dist/lib/ixo/blocksync/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/ixo/blocksync/types.ts"],"names":[],"mappings":"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"}

package/dist/lib/ixo/cellnode.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Cellnode — the LAST claim body lane, for collections that predate the Matrix claim bot and the VFS.
+ *
+ * The emerging-eco claims server (`emerging-claims-credentials`) still writes claim bodies to a
+ * cellnode and submits only the CID on chain, so those collections have no body in any Matrix room
+ * or VFS at all. Cellnode is being retired (Openhands moved its bodies to the VFS and IPFS), so it is
+ * asked last. The read is `verified-read.ts`'s: an unauthenticated `GET {cellnode}/public/{cid}`,
+ * safe because the bytes must hash to the claim id. (Their API docs call cellnode "private
+ * storage"; it is not — `/public/{cid}` answers anyone.)
+ *
+ * The host is only ever the one the entity itself declares (`type: "Cellnode"`). We never fall back
+ * to a per-network default: an entity that declares no cellnode is not a cellnode collection, and
+ * guessing a host would turn "wrong lane" into a confusing 404 from a stranger's server.
+ */
+import type { Logger } from "../logger.js";
+import type { TraceContext } from "../tracing.js";
+import type { IidService } from "./blocksync/types.js";
+import { type StoreRead } from "./verified-read.js";
+/**
+ * The cellnode base URL an entity declares, or null. Matched case-insensitively on `type`: the same
+ * service is spelled `Cellnode` on some entities and `CellNode` on others, and the portal/editor
+ * resolvers (`getFullServiceEndpoint`) already tolerate both plus a trailing slash.
+ *
+ * Some entities anchor the endpoint WITH the read path baked in (`…/public` — their readers do
+ * `endpoint + "/{cid}"`), others as the bare host (readers hit `/{cid}`, which cellnode also
+ * serves). Both spellings name the same lane, so normalize to the bare host — we always build
+ * `{base}/public/{cid}` ourselves, and a kept suffix would double it into a 404.
+ */
+export declare function cellnodeUrlFromServices(services: IidService[]): string | null;
+/** The claim body from a cellnode: 404 is a miss, any other failure `unavailable` (verified-read.ts). */
+export declare function getCellnodeClaimBody(deps: {
+    trace: TraceContext;
+    logger: Logger;
+}, cellnodeUrl: string, claimId: string): Promise<StoreRead>;
+//# sourceMappingURL=cellnode.d.ts.map

package/dist/lib/ixo/cellnode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cellnode.d.ts","sourceRoot":"","sources":["../../../src/lib/ixo/cellnode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,IAAI,CAQ7E;AAED,yGAAyG;AACzG,wBAAgB,oBAAoB,CAClC,IAAI,EAAE;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,CAAC,CAKpB"}

package/dist/lib/ixo/cellnode.js

@@ -0,0 +1,43 @@
+/**
+ * Cellnode — the LAST claim body lane, for collections that predate the Matrix claim bot and the VFS.
+ *
+ * The emerging-eco claims server (`emerging-claims-credentials`) still writes claim bodies to a
+ * cellnode and submits only the CID on chain, so those collections have no body in any Matrix room
+ * or VFS at all. Cellnode is being retired (Openhands moved its bodies to the VFS and IPFS), so it is
+ * asked last. The read is `verified-read.ts`'s: an unauthenticated `GET {cellnode}/public/{cid}`,
+ * safe because the bytes must hash to the claim id. (Their API docs call cellnode "private
+ * storage"; it is not — `/public/{cid}` answers anyone.)
+ *
+ * The host is only ever the one the entity itself declares (`type: "Cellnode"`). We never fall back
+ * to a per-network default: an entity that declares no cellnode is not a cellnode collection, and
+ * guessing a host would turn "wrong lane" into a confusing 404 from a stranger's server.
+ */
+import { readVerifiedClaim } from "./verified-read.js";
+/**
+ * The cellnode base URL an entity declares, or null. Matched case-insensitively on `type`: the same
+ * service is spelled `Cellnode` on some entities and `CellNode` on others, and the portal/editor
+ * resolvers (`getFullServiceEndpoint`) already tolerate both plus a trailing slash.
+ *
+ * Some entities anchor the endpoint WITH the read path baked in (`…/public` — their readers do
+ * `endpoint + "/{cid}"`), others as the bare host (readers hit `/{cid}`, which cellnode also
+ * serves). Both spellings name the same lane, so normalize to the bare host — we always build
+ * `{base}/public/{cid}` ourselves, and a kept suffix would double it into a 404.
+ */
+export function cellnodeUrlFromServices(services) {
+    const service = services.find((s) => s.type?.toLowerCase() === "cellnode");
+    const endpoint = service?.serviceEndpoint
+        ?.replace(/\s+/g, "")
+        .replace(/\/+$/, "")
+        .replace(/\/public$/, "");
+    if (!endpoint)
+        return null;
+    return /^https?:\/\//.test(endpoint) ? endpoint : `https://${endpoint}`;
+}
+/** The claim body from a cellnode: 404 is a miss, any other failure `unavailable` (verified-read.ts). */
+export function getCellnodeClaimBody(deps, cellnodeUrl, claimId) {
+    return readVerifiedClaim(deps, "cellnode", `${cellnodeUrl}/public/${claimId}`, claimId, {
+        attempts: 3,
+        headers: { accept: "application/ld+json, application/json" },
+    });
+}
+//# sourceMappingURL=cellnode.js.map

package/dist/lib/ixo/cellnode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cellnode.js","sourceRoot":"","sources":["../../../src/lib/ixo/cellnode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,EAAE,iBAAiB,EAAkB,MAAM,iBAAiB,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,UAAU,uBAAuB,CAAC,QAAsB;IAC5D,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,UAAU,CAAC,CAAC;IAC3E,MAAM,QAAQ,GAAG,OAAO,EAAE,eAAe;QACvC,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;SACpB,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;SACnB,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IAC5B,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC3B,OAAO,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,QAAQ,EAAE,CAAC;AAC1E,CAAC;AAED,yGAAyG;AACzG,MAAM,UAAU,oBAAoB,CAClC,IAA6C,EAC7C,WAAmB,EACnB,OAAe;IAEf,OAAO,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,WAAW,WAAW,OAAO,EAAE,EAAE,OAAO,EAAE;QACtF,QAAQ,EAAE,CAAC;QACX,OAAO,EAAE,EAAE,MAAM,EAAE,uCAAuC,EAAE;KAC7D,CAAC,CAAC;AACL,CAAC"}

package/dist/lib/ixo/chain-write.d.ts

@@ -0,0 +1,130 @@
+/**
+ * The act lane — acting on the verdict (README "How a claim flows" step 6). Runs as the `act` step in BOTH
+ * workflows (ClaimIngest after `evaluate`, ReviewComplete after the fold): durable step-native
+ * retries own delivery; the step reads the just-recorded decision and submits `MsgEvaluateClaim`
+ * through the sequence-manager DO. A trimmed port of eval-engine's chain-write.ts — no disputes,
+ * no zero-payout parking, no reconcile lane, no fee claims: the collection's evaluation payment IS
+ * this oracle's income, split 80/10/10 by the chain on this very message.
+ *
+ * Self-contained by design: `deliverChainEvaluation(deps, claimId)` reads everything it needs from
+ * the `decisions` row and the chain — including the claim's PAYMENT plane, which decides whether
+ * we may set the payout at all (payment.ts: ordinary claim ⇒ echo its coins · intent claim ⇒ send
+ * none, the escrow governs) — so both workflows pass only the claimId. A clean no-op (one log
+ * line) when: the row carries no terminal approve/reject (`pending_review` waits for the fold;
+ * `review` / `unusable` / `invalid_facts` never act), the policy says a human signs
+ * (`act.manual` — a manual-sign route is a later lane), `ORACLE_SECP_MNEMONIC` is unset, or the
+ * claim was already delivered (`chainStatus = submitted` — the delivered-once guard, since step
+ * retries re-enter), or the oracle's own act policy said `skip`.
+ *
+ * That policy (`policies.act`, src/act.ts) is the provider's seam on this lane: asked once every
+ * guard above has passed and before the grant is read, it may sign (with an amount only it can
+ * compute — a payout pooled across claims — which stands only where the collection's owner set
+ * `operatorAmounts: allowed`), `skip`, or HOLD the row (`chainStatus = held`, which is explicitly
+ * NOT a delivered state). `signEvaluation()` below is the release pass that signs a
+ * held row later, policy not consulted.
+ *
+ * `verification_proof` is the engine's signed receipt CID — the receipt is the engine's product
+ * (resolvable at its `/v1/receipts/:cid`, verifiable against its issuer keys), so a terminal
+ * decision WITHOUT one is a contract violation parked `blocked`, never delivered with an invented
+ * proof. The other park no retry can fix — a missing `EvaluateClaimAuthorization` (only the
+ * collection owner can grant it) — is `blocked` too, WITHOUT failing the step; a rerun re-attempts
+ * both. A failed broadcast records `chainError` and THROWS so the step retries with backoff —
+ * except the chain's "insufficient funds: payment withdrawal failed": the
+ * collection's admin account cannot pay what the message draws from it — the evaluation leg on
+ * EVERY evaluation, plus the approval payment on an ordinary approve or the rejection payment on a
+ * reject (`adminDraw`, payment.ts) — so no retry and no sibling claim can succeed until the owner
+ * tops it up. That one parks `blocked` AND pauses the collection `admin-unfunded` (the owner is
+ * told which account and how much, per denom); `cron/funding.ts` lifts the pause and re-delivers
+ * the parked rows once the balance covers the largest parked draw.
+ */
+import type { CoinSDKType } from "@ixo/impactxclient-sdk/types/codegen/cosmos/base/v1beta1/coin.js";
+import type { Config } from "../../config.js";
+import type { Database } from "../../db/client.js";
+import type { OracleEnv } from "../../env.js";
+import type { Logger } from "../logger.js";
+import type { Metrics } from "../metrics.js";
+import type { TraceContext } from "../tracing.js";
+export interface ChainWriteDeps {
+    config: Config;
+    logger: Logger;
+    metrics: Metrics;
+    trace: TraceContext;
+    db: Database;
+    sequenceManager: DurableObjectNamespace;
+    /** `env.CACHE_KV` / `env.EMAIL` — the `admin-unfunded` pause notice's lanes (workflows/steps.ts). */
+    cache: KVNamespace;
+    email?: SendEmail;
+    /**
+     * The worker env, handed STRAIGHT to the act policy (act.ts): the provider's hook runs inside
+     * this lane, and whatever it needs to decide — its own D1, a KV, a service binding — rides on
+     * the same env their `defineOracle()` worker was invoked with. Nothing else in here reads it.
+     */
+    env: OracleEnv;
+}
+export type ChainWriteOutcome = "submitted" | "skipped" | "blocked"
+/** The oracle's act policy is keeping this verdict back — `signEvaluation` releases it later. */
+ | "held"
+/** The chain already carried someone else's evaluation — recorded, not fought. */
+ | "owner_submitted";
+/**
+ * The MsgExec-wrapped `MsgEvaluateClaim` — grantee = this oracle's account, message shapes
+ * verbatim from subscriptions-api's `buildEvaluateClaimMsg`. `verificationProof` carries the
+ * engine's receipt CID: the proto documents the field as "the cid of the evaluation Verifiable
+ * Credential", and the receipt is exactly that.
+ *
+ * `claimAmount` is the ORDINARY lane's payout only (see `evaluationAmount`): by default the claim's
+ * own coins, in the claim's own denom — the kit never picks one. The oracle's act policy MAY
+ * (act.ts `ActDecision.amount`, or the caller of `signEvaluation`), denom included: a provider
+ * pooling several claims into one payout is the only party that can compute it. Omitted ⇒ the
+ * chain uses the collection's default approval payment (or, on an intent claim, the escrowed
+ * terms, which is why an override is ignored there).
+ */
+export declare function buildEvaluateClaimMsg(input: {
+    claimId: string;
+    collectionId: string;
+    adminAddress: string;
+    oracleAddress: string;
+    oracleDid: string;
+    claimAmount?: CoinSDKType;
+    /** 1 approve · 2 reject — the chain's own EvaluationStatus codes. */
+    evaluationStatus: 1 | 2;
+    verificationProof: string;
+}): Promise<{
+    typeUrl: string;
+    value: unknown;
+}>;
+/**
+ * The act step's delivery: the lane WITH the provider's act policy consulted (act.ts). Both
+ * workflows call this, and so does the funding cron's re-delivery of parked rows.
+ */
+export declare function deliverChainEvaluation(deps: ChainWriteDeps, claimId: string): Promise<ChainWriteOutcome>;
+/**
+ * The RELEASE pass: the same lane without the policy, for a row the policy `held`. A provider
+ * whose payout is pooled (a site paid once every patch on it is done) calls this when the pool
+ * closes, with the amount only they can compute — `@ixo/decision-oracle/runtime` exposes it env-first.
+ *
+ * Every other guard still holds: `AUTO_SIGN`, the mnemonic, the receipt, the frozen facts, an
+ * evaluation that already landed, and the grant — and `amount` is the policy's, so it stands only
+ * where the owner opted in (`operatorAmounts`); otherwise the lane's default is paid. A row that is already `submitted` /
+ * `owner_submitted` is `skipped`, so calling it twice cannot double-sign.
+ *
+ * One consequence worth knowing: a release that parks `blocked` (the admin-unfunded lane) is
+ * re-delivered later by `cron/funding.ts`, which goes through `deliverChainEvaluation` — so the
+ * policy IS consulted on that re-delivery and may hold the row again, and `amount` is this call's
+ * alone: the re-delivery pays the lane's default. Call this again once the pause lifts if the
+ * pooled amount still matters.
+ */
+export declare function signEvaluation(deps: ChainWriteDeps, claimId: string, amount?: {
+    denom: string;
+    amount: string;
+}): Promise<ChainWriteOutcome>;
+/**
+ * THE reading of the owner's yes, shared by the act lane (`operatorAmountsOf`) and the settings read
+ * (`GET /v1/collections/:id/settings`), so what a portal shows can never drift from what the lane
+ * pays: `allowed`, said by whoever is the live owner now. Pure — `owner` is the caller's live read.
+ */
+export declare function operatorAmountsEffective(watched: {
+    operatorAmounts: string;
+    operatorAmountsBy: string | null;
+}, owner: string | null): boolean;
+//# sourceMappingURL=chain-write.d.ts.map

package/dist/lib/ixo/chain-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-write.d.ts","sourceRoot":"","sources":["../../../src/lib/ixo/chain-write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kEAAkE,CAAC;AAGpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAI3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAM/C,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,YAAY,CAAC;IACpB,EAAE,EAAE,QAAQ,CAAC;IACb,eAAe,EAAE,sBAAsB,CAAC;IACxC,qGAAqG;IACrG,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;;OAIG;IACH,GAAG,EAAE,SAAS,CAAC;CAChB;AAyBD,MAAM,MAAM,iBAAiB,GACzB,WAAW,GACX,SAAS,GACT,SAAS;AACX,iGAAiG;GAC/F,MAAM;AACR,kFAAkF;GAChF,iBAAiB,CAAC;AAEtB;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,qEAAqE;IACrE,gBAAgB,EAAE,CAAC,GAAG,CAAC,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAkC/C;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,CAAC,CAE5B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACzC,OAAO,CAAC,iBAAiB,CAAC,CAE5B;AAkTD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACtE,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,OAAO,CAMT"}