@multiagency/sdk 0.3.1

package/dist/contract/owner-contract.js

@@ -0,0 +1,37 @@
+import { eventIterator, oc } from "@orpc/contract";
+import { z } from "zod";
+import { executePlanInput, ownerPrepareInput, ownerStatusInput, ownerSubmitInput } from "./inputs.js";
+import { ownerOutputs } from "./owner-outputs.js";
+/**
+ * Typed owner errors: recovery is decided by `data.kind`, never by message text. Every schema is loose, so an
+ * error's data reaches the client exactly as raised (oRPC sends the validated value; nothing may be stripped).
+ * Data that does not match (for example input validation's `{ issues }`) is sent unchanged as an undefined error.
+ */
+const refused = z.looseObject({ kind: z.literal("refused"), code: z.string().optional() });
+export const ownerErrors = {
+    /** Refused before anything was sent: an earlier operation has no proven outcome, or another action holds the lock. */
+    CONFLICT: { data: z.discriminatedUnion("kind", [z.looseObject({ kind: z.literal("unresolved") }), z.looseObject({ kind: z.literal("busy") }), refused]) },
+    /** Refused by the platform, or by the provider (with its code and supplementary details). */
+    BAD_REQUEST: { data: z.discriminatedUnion("kind", [refused, z.looseObject({
+                kind: z.literal("provider"), code: z.string().optional(), availableAt: z.string().nullable(), budgetRemainingUsd: z.string().optional(),
+            })]) },
+};
+const procedure = oc.errors(ownerErrors);
+/**
+ * The owner contract, contract-first: inputs, outputs and typed errors in one place. The server implements it
+ * (src/rpc/*, `implement` with output validation off: reads validate only, mutations and streams are not validated
+ * server-side) and `ownerClient` is typed from it.
+ */
+export const ownerContract = {
+    overview: procedure.output(ownerOutputs.overview),
+    activity: procedure.output(ownerOutputs.activity),
+    unresolved: procedure.output(ownerOutputs.unresolved),
+    strategy: { get: procedure.output(ownerOutputs["strategy/get"]) },
+    owner: {
+        prepare: procedure.input(ownerPrepareInput).output(ownerOutputs["owner/prepare"]),
+        submit: procedure.input(ownerSubmitInput).output(ownerOutputs["owner/submit"]),
+        status: procedure.input(ownerStatusInput).output(ownerOutputs["owner/status"]),
+    },
+    rebalance: procedure.output(eventIterator(ownerOutputs.rebalance)),
+    executePlan: procedure.input(executePlanInput).output(eventIterator(ownerOutputs.executePlan)),
+};

package/dist/contract/owner-inputs.d.ts

@@ -0,0 +1,166 @@
+import type { z } from "zod";
+import type { agreementCommand, compensationSend, paymentPreparation, reviewCommand } from "../compensation-contract.js";
+import type { depositInput, executePlanInput, ownerAction, ownerPrepareInput, ownerStatusInput, ownerSubmitInput, payoutRequestInput, payoutStatusInput } from "./inputs.js";
+/**
+ * Owner procedure inputs as the router accepts them (before server-side parsing). Procedures in the owner contract
+ * (owner-contract.ts) take their types from its schemas; test/contract-owner.test.ts proves each type equals the router's.
+ */
+type ReviewedPolicy = {
+    revision: number;
+    digest: string;
+};
+type Strategy = {
+    targetBps: Record<string, number>;
+    minLegUsd: number;
+    maxCostBps: number;
+    autopilot: {
+        everyMin: number;
+        maxUsd: number;
+    };
+};
+/** An owner action to prepare for signature, as the contract accepts it. */
+export type OwnerAction = z.input<typeof ownerAction>;
+type In<T extends z.ZodType> = z.input<T>;
+export type OwnerInputs = {
+    setup: undefined;
+    instance: undefined;
+    overview: undefined;
+    policyHistory: undefined;
+    activity: undefined;
+    unresolved: undefined;
+    held: undefined;
+    "inbox/list": undefined;
+    "autopilot/get": undefined;
+    "autopilot/evidence": {
+        since?: string;
+    };
+    "autopilot/log": {
+        tickId?: string;
+    };
+    "strategy/get": undefined;
+    "treasury/get": undefined;
+    ledger: undefined;
+    ledgerCsv: undefined;
+    reconcileBooks: undefined;
+    paymentHistory: undefined;
+    paymentStatus: {
+        correlationId: string;
+        waitMs?: number;
+    };
+    invoices: undefined;
+    "agreements/list": undefined;
+    "owner/status": In<typeof ownerStatusInput>;
+    "owner/pending": undefined;
+    "owner/actions": undefined;
+    "compensation/list": undefined;
+    "workOrders/list": undefined;
+    "workOrders/get": {
+        id: string;
+    };
+    "workOrders/status": {
+        id: string;
+        correlationId: string;
+    };
+    pay: {
+        recipient: string;
+        asset: string;
+        amount: string;
+        confidential: boolean;
+        expectedPolicy: ReviewedPolicy;
+    };
+    deposit: In<typeof depositInput>;
+    recover: undefined;
+    cancelPreparedInvoice: {
+        id: string;
+    };
+    "inbox/dismiss": {
+        id: string;
+    };
+    "owner/prepare": In<typeof ownerPrepareInput>;
+    "owner/submit": In<typeof ownerSubmitInput>;
+    "payouts/request": In<typeof payoutRequestInput>;
+    "payouts/status": In<typeof payoutStatusInput>;
+    "agreements/propose": {
+        id: string;
+        until: string;
+    };
+    "agreements/offer": {
+        payee: string;
+        amount: string;
+        note: string;
+        until: string;
+    };
+    "agreements/decline": {
+        id: string;
+    };
+    "compensation/agreement": z.input<typeof agreementCommand>;
+    "compensation/review": z.input<typeof reviewCommand>;
+    "compensation/prepare": z.input<typeof paymentPreparation>;
+    "compensation/send": z.input<typeof compensationSend>;
+    "workOrders/create": {
+        id: string;
+        payee: string;
+        amount: string;
+        note: string;
+        until: string;
+    };
+    "workOrders/prepare": {
+        id: string;
+        action: "create" | "grant" | "approve" | "reject" | "revoke";
+        signer: "wallet" | "dao";
+    };
+    "workOrders/submit": {
+        id: string;
+        correlationId: string;
+        signedData: Record<string, unknown>;
+    };
+    "workOrders/deposit": {
+        id: string;
+    };
+    "workOrders/file": {
+        id: string;
+    };
+    "strategy/save": {
+        strategy: Strategy;
+        expectedDigest: string;
+    };
+    "autopilot/set": {
+        on: boolean;
+        everyMin: number;
+        maxUsd: number;
+        expectedDigest?: string;
+    };
+    "autopilot/enable": {
+        expectedDigest: string;
+    };
+    "autopilot/stop": undefined;
+    "autopilot/tick": undefined;
+    "treasury/link": {
+        accountId: string;
+    };
+    "treasury/unlink": undefined;
+    "treasury/setConfidential": {
+        confidential: boolean;
+    };
+    "treasury/fund": {
+        asset: "USDC" | "NEAR";
+        amount: string;
+    };
+    externalPlan: {
+        swaps: {
+            from: string;
+            to: string;
+            amount: string;
+            minAmountOut?: string;
+        }[];
+    };
+    rebalance: undefined;
+    executePlan: In<typeof executePlanInput>;
+    sweep: {
+        execute: boolean;
+    };
+    "steward/propose": {
+        instruction?: string;
+    };
+};
+export {};

package/dist/contract/owner-inputs.js

@@ -0,0 +1 @@
+export {};