@ixo/oracle-runtime-workers 0.41.3 → 0.42.1

package/src/plugins/pod-creator/create-tools.ts

@@ -6,6 +6,8 @@ import {
   buildBatchSignTransactionActionArgs,
   describeValidationError,
   validateTransactionBatch,
+  type BatchMessageRoute,
+  type ITrxMsg,
   type Network,
   type RiskConfirmation,
   type ValidatedTransactionBatch,
@@ -22,6 +24,7 @@ import {
   notConfiguredChainGateway,
   podBatchProblem,
   type ChainGateway,
+  type PodConfirmation,
 } from './chain-gateway';
 import { readPodCreatorConfig } from './config';
 import type { CreateSessionStoreFor } from './create-session-store';
@@ -48,6 +51,49 @@ const TX_HASH_PATTERN = /^[0-9a-fA-F]{64}$/;
 /** The blob store name of a prepared batch. */
 export const POD_BATCH_BLOB_NAME = 'pod-batch-messages';
 
+/**
+ * Characters plain text never carries: format characters (bidi overrides,
+ * zero-width), line and paragraph separators, private-use and unassigned
+ * code points.
+ */
+const INVISIBLE_CHARACTERS = /[\p{Cf}\p{Zl}\p{Zp}\p{Co}\p{Cn}]/u;
+/** Control characters, which a one-line name never carries. */
+const CONTROL_CHARACTERS = /\p{Cc}/u;
+/** Control characters other than a line break or a tab. */
+const CONTROL_EXCEPT_LINES = /[^\P{Cc}\n\t]/u;
+
+/** The longest POD description: it is quoted in full in the batch summary the user approves. */
+export const MAX_POD_DESCRIPTION_LENGTH = 600;
+
+const prepareSchema = z.object({
+  name: z
+    .string()
+    .trim()
+    .min(1)
+    .max(100)
+    .refine(
+      (name) =>
+        !CONTROL_CHARACTERS.test(name) && !INVISIBLE_CHARACTERS.test(name),
+      { message: 'The name is one line of plain text.' },
+    )
+    .describe(
+      "The POD's name exactly as the user agreed it in the design (plain text, at most 100 characters). It is the name on the POD's public profile.",
+    ),
+  description: z
+    .string()
+    .trim()
+    .max(MAX_POD_DESCRIPTION_LENGTH)
+    .refine(
+      (text) =>
+        !CONTROL_EXCEPT_LINES.test(text) && !INVISIBLE_CHARACTERS.test(text),
+      { message: 'The description is plain text.' },
+    )
+    .optional()
+    .describe(
+      `One or two plain sentences on what the POD does, from the design (at most ${MAX_POD_DESCRIPTION_LENGTH} characters). Shown on its public profile.`,
+    ),
+});
+
 const blobIdSchema = z.object({
   blobId: z
     .string()
@@ -60,6 +106,17 @@ const approveSchema = blobIdSchema.extend({
   ),
 });
 
+const emptySchema = z.object({});
+
+const ADD_LINKED_RESOURCE = '/ixo.iid.v1beta1.MsgAddLinkedResource';
+/** The linked resource id of an entity's domain card, which the chain fills in. */
+const DOMAIN_CARD_RESOURCE_ID = '{id}#dmn';
+
+const domainCardMessageSchema = z.object({
+  id: z.string(),
+  linkedResource: z.object({ id: z.string() }),
+});
+
 const confirmSchema = z.object({
   txHash: z
     .string()
@@ -77,15 +134,31 @@ const storedBatchSchema = z
     network: NetworkSchema,
     summary: z.string(),
     messages: z.array(ITrxMsgSchema),
+    /** The profile the user agreed, for the POD's domain card later. */
+    profile: z.object({
+      name: z.string(),
+      description: z.string().optional(),
+    }),
+    /** The documents the messages name, uploaded after approval. */
+    documents: z.array(
+      z
+        .object({
+          mxc: z.string(),
+          contentType: z.string(),
+          filename: z.string(),
+          text: z.string(),
+        })
+        .strict(),
+    ),
   })
   .strict();
 
 type StoredBatch = z.infer<typeof storedBatchSchema>;
 
 const CHAIN_UNAVAILABLE_MESSAGE =
-  'On-chain POD creation is not yet enabled on this oracle — the chain ' +
-  'gateway is not configured. The design blueprint is saved; creation can ' +
-  'proceed once the operator wires the IXO MCP chain gateway.';
+  'On-chain POD creation is turned off on this oracle: it was built ' +
+  'without a chain gateway. The design blueprint is saved; creating the ' +
+  'POD on chain needs an oracle that has one.';
 
 /**
  * Validate a blobId and return the stored batch, throwing when it is missing,
@@ -137,7 +210,12 @@ function validateStoredBatch(
   },
 ): ValidatedTransactionBatch {
   return validateTransactionBatch(
-    { ...batch, riskConfirmation: options.riskConfirmation },
+    {
+      network: batch.network,
+      summary: batch.summary,
+      messages: batch.messages,
+      riskConfirmation: options.riskConfirmation,
+    },
     {
       allowMainnet: options.mainnetAllowed,
       requireRiskConfirmation: options.riskConfirmation !== undefined,
@@ -183,6 +261,42 @@ export type RequestPodSignatureResult =
     }
   | { status: 'unavailable'; error: string; message: string };
 
+/** What `confirm_pod_creation` returns to the model. */
+export type ConfirmPodCreationResult =
+  | {
+      created: true;
+      podDid: string;
+      /** The POD in the Portal. */
+      portalUrl: string;
+      summary: string;
+      message: string;
+    }
+  | {
+      created: false;
+      status: Exclude<PodConfirmation['status'], 'created'>;
+      /** True: call again later with the same hash. */
+      retryable: boolean;
+      message: string;
+    };
+
+/** What `add_pod_domain_card` returns to the model. */
+export type AddPodDomainCardResult =
+  | { status: 'added'; podDid: string; txHash?: string; message: string }
+  | { status: 'refused'; message: string }
+  | {
+      status: 'failed';
+      code: number;
+      txHash?: string;
+      error: string;
+      message: string;
+    }
+  | {
+      status: 'rejected' | 'error' | 'unavailable';
+      error: string;
+      message: string;
+    }
+  | { status: 'timeout'; outcome: 'unknown'; error: string };
+
 const RETRY_AFTER_SPENT_APPROVAL =
   'Nothing was signed and the approval was spent: to retry, the user confirms again in a new message and you call approve_pod_transaction, then request_pod_signature.';
 
@@ -229,7 +343,8 @@ export function createCreateTools(
   const chainUnavailable = gateway === notConfiguredChainGateway;
 
   const prepare = tool(
-    async (_args, ctx) => {
+    async (args, ctx) => {
+      const profile = prepareSchema.parse(args);
       const bp = await blueprintsFor(ctx).get(threadId(ctx));
       if (!bp) {
         return {
@@ -261,9 +376,21 @@ export function createCreateTools(
       }
       const blueprint = assembleServicePodBlueprint(bp);
       const prepared = await gateway.preparePodBatch(
-        { blueprint, network },
+        { blueprint, network, profile },
         ctx,
       );
+      if (!prepared.ok) {
+        ctx.logger.warn(
+          `[pod-creator] prepare refused user=${ctx.user.did} thread=${threadId(ctx)}: ${prepared.message}`,
+        );
+        return {
+          prepared: false,
+          retryable: prepared.retryable,
+          message: prepared.retryable
+            ? `${prepared.message} Nothing was prepared; call prepare_pod_transaction again shortly.`
+            : `${prepared.message} Nothing was prepared; tell the user what is needed.`,
+        };
+      }
       // The wallet's handler refuses anything outside the catalog, so a
       // batch it would refuse is caught here, before the user is asked.
       let batch: ValidatedTransactionBatch;
@@ -289,6 +416,8 @@ export function createCreateTools(
         network: batch.network,
         summary: batch.summary,
         messages: batch.messages,
+        profile,
+        documents: prepared.documents,
       };
       const blobId = await ctx.blobStore.put({
         userDid: ctx.user.did,
@@ -307,6 +436,8 @@ export function createCreateTools(
       return {
         prepared: true,
         blobId,
+        name: profile.name,
+        description: profile.description ?? '',
         summary: batch.summary,
         messageCount: batch.messages.length,
         messages: batch.routes.map((route) => route.messageName),
@@ -316,14 +447,14 @@ export function createCreateTools(
           ? { estimatedCost: prepared.estimatedCost }
           : {}),
         message:
-          'Transaction batch prepared. Show the user the summary and every risk, word for word, and stop: approve_pod_transaction only works on a later message in which the user explicitly confirms, and needs each risk they accepted quoted exactly.',
+          'Transaction batch prepared. Show the user the summary (with the exact public name and description) and every risk, word for word, and stop: approve_pod_transaction only works on a later message in which the user explicitly confirms, and needs each risk they accepted quoted exactly. Nothing is public yet: the profile is published only after their approval.',
       };
     },
     {
       name: 'prepare_pod_transaction',
       description:
-        'Build the on-chain POD creation batch (unsigned messages) from the approved blueprint and stash it for the user to sign. Returns its summary, message names and risks. Only works once the launch-readiness gate has passed; refuses on mainnet unless the operator opted in.',
-      schema: z.object({}),
+        "Build the on-chain POD creation batch (unsigned messages) from the approved blueprint, with the POD's name and description from the design, and stash it for the user to sign in their own wallet. Reserves the POD's public profile (name and description), which is published only once the user approved the batch. Returns its summary, message names and risks, or prepared: false with what is missing. Only works once the launch-readiness gate has passed; refuses on mainnet unless the operator opted in.",
+      schema: prepareSchema,
     },
   );
 
@@ -418,21 +549,45 @@ export function createCreateTools(
       const risks = validateStoredBatch(batch, { mainnetAllowed }).risks;
       const signArgs = buildBatchSignTransactionActionArgs(
         {
-          ...batch,
+          network: batch.network,
+          summary: batch.summary,
+          messages: batch.messages,
           riskConfirmation: { confirmed: true, acceptedRisks: risks },
         },
         { allowMainnet: mainnetAllowed, chainIds },
       );
+      const notApproved = new Error(
+        'Transaction not approved (or its approval was already used). Call approve_pod_transaction after the user explicitly confirms the batch.',
+      );
+      const session = await sessionsFor(ctx).read(ctx.user.did, threadId(ctx));
+      if (session?.approvedBlobId !== blobId) throw notApproved;
+      // The profile becomes public only now, after the user's approval and
+      // before it is spent: a homeserver that is down keeps the approval.
+      if (batch.documents.length > 0) {
+        const published = await gateway.publishDocuments(
+          { documents: batch.documents },
+          ctx,
+        );
+        if (!published.ok) {
+          ctx.logger.warn(
+            `[pod-creator] profile not published for batch ${blobId} user=${ctx.user.did}: ${published.message}`,
+          );
+          return {
+            status: 'unavailable',
+            error: published.message,
+            message: published.retryable
+              ? "Nothing was sent and the approval is kept: the POD's profile could not be published yet. Call request_pod_signature again in a moment."
+              : "Nothing was sent: the POD's profile cannot be published from this batch. Call prepare_pod_transaction again, show the user the new batch and ask them to approve it.",
+          };
+        }
+      }
       const consumed = await sessionsFor(ctx).consume(
         ctx.user.did,
         threadId(ctx),
         blobId,
+        { messages: batch.messages, profile: batch.profile },
       );
-      if (!consumed) {
-        throw new Error(
-          'Transaction not approved (or its approval was already used). Call approve_pod_transaction after the user explicitly confirms the batch.',
-        );
-      }
+      if (!consumed) throw notApproved;
       const outcome = await requestWalletSignature(ctx, {
         args: signArgs,
         callIdPrefix: 'pod',
@@ -506,33 +661,253 @@ export function createCreateTools(
   );
 
   const confirm = tool(
-    async (args, ctx) => {
+    async (args, ctx): Promise<ConfirmPodCreationResult> => {
       const { txHash } = confirmSchema.parse(args);
       if (chainUnavailable) {
-        return { created: false, message: CHAIN_UNAVAILABLE_MESSAGE };
+        return {
+          created: false,
+          status: 'unavailable',
+          retryable: false,
+          message: CHAIN_UNAVAILABLE_MESSAGE,
+        };
       }
-      const { network } = readPodCreatorConfig(ctx);
-      const created = await gateway.confirmPodCreation(
-        { txHash, network },
+      const sessions = sessionsFor(ctx);
+      const session = await sessions.read(ctx.user.did, threadId(ctx));
+      if (!session?.sent) {
+        return {
+          created: false,
+          status: 'failed',
+          retryable: false,
+          message:
+            'No POD batch was sent for signing in this conversation (or it was more than an hour ago), so there is nothing to confirm here. A POD is confirmed in the conversation that prepared and sent it.',
+        };
+      }
+      const { network, portalUrl } = readPodCreatorConfig(ctx);
+      const outcome = await gateway.confirmPodCreation(
+        { txHash, network, sent: session.sent },
         ctx,
       );
-      await sessionsFor(ctx).clear(ctx.user.did, threadId(ctx));
-      ctx.logger.log(
-        `[pod-creator] confirmed POD ${created.podDid} tx=${txHash} user=${ctx.user.did} thread=${threadId(ctx)}`,
-      );
+      const audit = `tx=${txHash} user=${ctx.user.did} thread=${threadId(ctx)}`;
+      if (outcome.status !== 'created') {
+        ctx.logger.warn(
+          `[pod-creator] confirm ${outcome.status} ${audit}: ${outcome.message}`,
+        );
+        return {
+          created: false,
+          status: outcome.status,
+          retryable: outcome.retryable,
+          message: outcome.message,
+        };
+      }
+      await sessions.confirmed(ctx.user.did, threadId(ctx), {
+        podDid: outcome.podDid,
+        txHash,
+      });
+      ctx.logger.log(`[pod-creator] confirmed POD ${outcome.podDid} ${audit}`);
       return {
         created: true,
-        podDid: created.podDid,
-        summary: created.summary,
+        podDid: outcome.podDid,
+        portalUrl: `${portalUrl}/domain/${outcome.podDid}/overview`,
+        summary: outcome.summary,
+        message:
+          "Tell the user the POD exists and give them its Portal link; its public profile (name and description) is published. Then offer the next step: add the POD's public domain card (add_pod_domain_card, one more wallet signature), so the Portal lists it and search finds it.",
       };
     },
     {
       name: 'confirm_pod_creation',
       description:
-        'Confirm the POD was created on-chain from the signed transaction hash; returns the new POD DID.',
+        'Confirm the POD was created on chain from the signed transaction hash; returns the new POD DID and its Portal link. Reads the chain for up to 20 s: created: false with status pending (not on chain yet) or unavailable (chain not readable) and retryable: true means call it again later with the same hash; status failed means no POD of this conversation was created (do not retry).',
       schema: confirmSchema,
+      effect: 'read',
+    },
+  );
+
+  const addDomainCard = tool(
+    async (args, ctx): Promise<AddPodDomainCardResult> => {
+      emptySchema.parse(args);
+      if (chainUnavailable) {
+        return {
+          status: 'unavailable',
+          error: CHAIN_UNAVAILABLE_MESSAGE,
+          message: 'Nothing was sent.',
+        };
+      }
+      const { network, mainnetAllowed, chainIds } = readPodCreatorConfig(ctx);
+      if (network === 'mainnet' && !mainnetAllowed) {
+        return {
+          status: 'refused',
+          message:
+            'Mainnet POD creation is disabled on this oracle (POD_CREATOR_ALLOW_MAINNET), so no domain card is added.',
+        };
+      }
+      const unavailable = walletUnavailableReason(ctx);
+      if (unavailable !== null) {
+        return {
+          status: 'unavailable',
+          error: unavailable,
+          message:
+            'Nothing was sent: call add_pod_domain_card again once the user has the chat open in the Portal.',
+        };
+      }
+      const sessions = sessionsFor(ctx);
+      const claim = await sessions.claimCard(ctx.user.did, threadId(ctx));
+      if (claim.status === 'no-pod') {
+        return {
+          status: 'refused',
+          message:
+            'No POD was confirmed in this conversation (confirm_pod_creation first), so there is no POD to add a domain card to.',
+        };
+      }
+      if (claim.status === 'claimed') {
+        return {
+          status: 'refused',
+          message:
+            claim.state === 'added'
+              ? 'The domain card of this POD was already added; it is added once.'
+              : 'The domain card of this POD was already sent to the wallet and its outcome is not known. Ask the user whether they signed it; do not send it again.',
+        };
+      }
+      const { podDid } = claim;
+      const release = () =>
+        sessions.settleCard(ctx.user.did, threadId(ctx), 'released');
+      const prepared = await gateway.prepareDomainCard(
+        { network, podDid, profile: claim.sent.profile },
+        ctx,
+      );
+      if (!prepared.ok) {
+        await release();
+        return {
+          status: 'unavailable',
+          error: prepared.message,
+          message: prepared.retryable
+            ? 'Nothing was sent: call add_pod_domain_card again in a moment.'
+            : 'Nothing was sent: tell the user what is needed.',
+        };
+      }
+      let signArgs: ReturnType<typeof buildBatchSignTransactionActionArgs>;
+      try {
+        const batch = validateTransactionBatch(
+          { messages: prepared.messages, summary: prepared.summary, network },
+          { allowMainnet: mainnetAllowed },
+        );
+        const notCard = domainCardBatchProblem(batch.routes, prepared, podDid);
+        if (notCard !== null) throw new Error(notCard);
+        // The user reviews and signs the card in the Portal's own consent
+        // prompt: an update of an entity they own, nothing else.
+        signArgs = buildBatchSignTransactionActionArgs(
+          {
+            network,
+            summary: batch.summary,
+            messages: batch.messages,
+            riskConfirmation: { confirmed: true, acceptedRisks: batch.risks },
+          },
+          { allowMainnet: mainnetAllowed, chainIds },
+        );
+      } catch (error) {
+        await release();
+        throw new Error(
+          `The chain gateway built a domain card batch the wallet would refuse: ${describeValidationError(error)}`,
+        );
+      }
+      const published = await gateway.publishDocuments(
+        { documents: prepared.documents },
+        ctx,
+      );
+      if (!published.ok) {
+        await release();
+        return {
+          status: 'unavailable',
+          error: published.message,
+          message: published.retryable
+            ? 'Nothing was sent: the card could not be published yet. Call add_pod_domain_card again in a moment.'
+            : 'Nothing was sent: the card could not be published. Tell the user.',
+        };
+      }
+      const outcome = await requestWalletSignature(ctx, {
+        args: signArgs,
+        callIdPrefix: 'pod_card',
+        timeoutMs: SIGN_TIMEOUT_MS,
+      });
+      const audit = `card of ${podDid} user=${ctx.user.did} thread=${threadId(ctx)}`;
+      switch (outcome.status) {
+        case 'signed': {
+          await sessions.settleCard(ctx.user.did, threadId(ctx), 'added');
+          ctx.logger.log(
+            `[pod-creator] wallet signed ${audit} tx=${outcome.transactionHash ?? 'none'}`,
+          );
+          await gateway.requestIndexing({ network, podDid }, ctx);
+          return {
+            status: 'added',
+            podDid,
+            ...(outcome.transactionHash !== undefined
+              ? { txHash: outcome.transactionHash }
+              : {}),
+            message:
+              'The domain card was added. The domain indexer was asked to index the POD; it can take a few minutes to show in the Portal lists and search.',
+          };
+        }
+        case 'failed':
+          await release();
+          ctx.logger.warn(
+            `[pod-creator] card failed on chain ${audit} code=${outcome.code}`,
+          );
+          return {
+            status: 'failed',
+            code: outcome.code,
+            ...(outcome.transactionHash !== undefined
+              ? { txHash: outcome.transactionHash }
+              : {}),
+            error: outcome.error,
+            message:
+              'The transaction failed on chain, so no card was added. Tell the user the code and error.',
+          };
+        case 'rejected':
+        case 'error':
+        case 'unavailable':
+          await release();
+          ctx.logger.warn(
+            `[pod-creator] card ${outcome.status} ${audit}: ${outcome.error}`,
+          );
+          return {
+            status: outcome.status,
+            error: outcome.error,
+            message:
+              'Nothing was signed. If the user wants the card, call add_pod_domain_card again.',
+          };
+        case 'timeout':
+          ctx.logger.warn(`[pod-creator] card outcome unknown ${audit}`);
+          return outcome;
+      }
+    },
+    {
+      name: 'add_pod_domain_card',
+      description:
+        "After confirm_pod_creation: add the new POD's public domain card (its name and description, as the Portal publishes for a domain it creates) with one wallet signature in the Portal, then ask the domain indexer to index it, so the POD shows in the Portal's lists and search. Offer it to the user; it runs once per POD.",
+      schema: emptySchema,
     },
   );
 
-  return [prepare, approve, requestSignature, confirm];
+  return [prepare, approve, requestSignature, confirm, addDomainCard];
+}
+
+/**
+ * Why a validated batch is not the domain card of `podDid`, or null when it
+ * is: one `MsgAddLinkedResource` on the POD, its `{id}#dmn` card.
+ */
+function domainCardBatchProblem(
+  routes: readonly BatchMessageRoute[],
+  prepared: { messages: readonly ITrxMsg[] },
+  podDid: string,
+): string | null {
+  const [message] = prepared.messages;
+  const card = domainCardMessageSchema.safeParse(message?.value);
+  if (
+    routes.length !== 1 ||
+    routes[0]?.typeUrl !== ADD_LINKED_RESOURCE ||
+    !card.success ||
+    card.data.id !== podDid ||
+    card.data.linkedResource.id !== DOMAIN_CARD_RESOURCE_ID
+  )
+    return `A domain card batch is one ${ADD_LINKED_RESOURCE} of ${DOMAIN_CARD_RESOURCE_ID} on ${podDid}`;
+  return null;
 }

package/src/plugins/pod-creator/domain-card.ts

@@ -0,0 +1,67 @@
+import type { PodProfile } from './chain-gateway';
+
+/**
+ * A POD's domain card, as the Portal composes a fresh one for a domain it
+ * creates (ixo-portal `lib/entity/domainCard.ts`, `freshDomainCardDocument`):
+ * a W3C VerifiableCredential of type `ixo:DomainCard` issued by the owner,
+ * whose subject is the entity. The domain indexer reads it from the entity's
+ * `{id}#dmn` linked resource to list and search the domain. No logo, image,
+ * tags or purpose: the POD creator collects only the name and description.
+ */
+export function podDomainCardDocument(input: {
+  podDid: string;
+  ownerDid: string;
+  profile: PodProfile;
+  validFrom: string;
+}): Record<string, unknown> {
+  const { podDid, ownerDid, profile, validFrom } = input;
+  return {
+    '@context': [
+      'https://www.w3.org/ns/credentials/v2',
+      'https://w3id.org/ixo/context/v1',
+      {
+        attribute: 'https://w3id.org/ixo/attributes/v1/',
+        schema: 'https://schema.org/',
+        ixo: 'https://w3id.org/ixo/vocab/v1',
+        prov: 'http://www.w3.org/ns/prov#',
+        proj: 'https://linked.data.gov.au/def/project#',
+        xsd: 'http://www.w3.org/2001/XMLSchema#',
+        id: '@id',
+        type: '@type',
+        'ixo:vector': { '@container': '@list', '@type': 'xsd:double' },
+        '@protected': true,
+      },
+    ],
+    id: `${podDid}#dmn`,
+    type: ['VerifiableCredential', 'ixo:DomainCard'],
+    issuer: { id: ownerDid },
+    validFrom,
+    credentialSchema: {
+      id: 'https://w3id.org/ixo/schemas/ixo-domain-card-1.json',
+      type: 'JsonSchema',
+    },
+    credentialSubject: {
+      id: podDid,
+      type: ['ixo:Domain'],
+      additionalType: ['schema:Organization'],
+      name: profile.name,
+      description: profile.description ?? '',
+      sameAs: [],
+      logo: { type: 'schema:ImageObject', id: '', contentUrl: '' },
+      image: [{ type: 'schema:ImageObject', id: '', contentUrl: '' }],
+      keywords: [],
+      knowsAbout: [],
+      composition: { type: 'schema:Collection', hasPart: [] },
+      makesOffer: [],
+      relationships: {
+        'prov:wasAssociatedWith': [],
+        memberOf: [],
+        funding: [],
+      },
+      agents: [],
+      credentials: [],
+      attributes: [],
+      project: {},
+    },
+  };
+}

package/src/plugins/pod-creator/index.ts

@@ -37,10 +37,17 @@ export {
   type Readiness,
 } from './stage';
 export { createOrchestrationTools } from './orchestration-tools';
-export { buildStageSubAgents } from './sub-agents';
 export {
+  buildSpecialistSubAgents,
+  buildStageSubAgents,
+  createSpecialistStageMiddleware,
+} from './sub-agents';
+export {
+  MAX_POD_DESCRIPTION_LENGTH,
   SIGN_TRANSACTION_ACTION,
   createCreateTools,
+  type AddPodDomainCardResult,
+  type ConfirmPodCreationResult,
   type RequestPodSignatureResult,
 } from './create-tools';
 export {
@@ -48,17 +55,32 @@ export {
   notConfiguredChainGateway,
   podBatchProblem,
   type ChainGateway,
-  type CreatedPod,
+  type GatewayRefusal,
+  type GatewayResult,
+  type PendingDocument,
+  type PodConfirmation,
+  type PodProfile,
   type PreparedPodBatch,
+  type SentPodBatch,
 } from './chain-gateway';
+export {
+  createIxoChainGateway,
+  podProfileDocument,
+  type IxoChainGatewayDeps,
+} from './ixo-chain-gateway';
+export { podDomainCardDocument } from './domain-card';
 export {
   KvCreateSessionStore,
   type ApproveOutcome,
+  type CardClaim,
   type CreateSessionStore,
+  type CreateSessionView,
   type CreateSessionStoreFor,
 } from './create-session-store';
 export {
   DEFAULT_NETWORK,
+  POD_RELAYER_NODE_DIDS,
+  PORTAL_URLS,
   podCreatorConfigSchema,
   readPodCreatorConfig,
 } from './config';