@multiagency/sdk 0.3.1

package/dist/contract/inputs.d.ts

@@ -0,0 +1,230 @@
+import { z } from "zod";
+/**
+ * Owner procedure inputs: the one source the server implements (src/rpc/*) and clients are typed from
+ * (owner-contract.ts). Pure schemas only, so the package stays browser-safe.
+ */
+export declare const run: z.ZodObject<{
+    execute: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const account: z.ZodString;
+export declare const transferAccount: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const units: z.ZodString;
+/** A NEAR account paid by withdrawal to chain `near`: never a `nearcom:` address, which is not on any chain. */
+export declare const nearAccount: z.ZodString;
+/** A USD amount in the policy's budget; null leaves that window uncapped. */
+export declare const usdAmount: z.ZodNullable<z.ZodString>;
+/** Per-asset caps in raw units. */
+export declare const caps: z.ZodRecord<z.ZodString, z.ZodString>;
+export declare const reviewedPolicy: z.ZodObject<{
+    revision: z.ZodNumber;
+    digest: z.ZodString;
+}, z.core.$strip>;
+/**
+ * What a grant's label says it is for: the agent's own strategies, its payouts, or invoices (the
+ * public invoice page). Each purpose (see authorize.ts) names the grant labels that may act for it.
+ */
+export declare const GRANT_LABELS: readonly ["treasury", "payout", "invoices"];
+export type GrantLabel = (typeof GRANT_LABELS)[number];
+/** An owner action to prepare for signature (owner-intents.ts `prepare`). */
+export declare const ownerAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"agent_create">;
+    owner: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"near">;
+        account_id: z.ZodString;
+        public_key: z.ZodString;
+    }, z.core.$strip>>;
+    role: z.ZodOptional<z.ZodEnum<{
+        payout: "payout";
+        treasury: "treasury";
+    }>>;
+    payees: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"grant_issue">;
+    label: z.ZodOptional<z.ZodEnum<{
+        invoices: "invoices";
+        payout: "payout";
+        treasury: "treasury";
+    }>>;
+    suffix: z.ZodOptional<z.ZodString>;
+    expectedStrategyDigest: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"grant_revoke">;
+    grantId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"agent_freeze">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"agent_unfreeze">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"policy_update">;
+    expectedPolicy: z.ZodObject<{
+        revision: z.ZodNumber;
+        digest: z.ZodString;
+    }, z.core.$strip>;
+    changes: z.ZodObject<{
+        swap: z.ZodOptional<z.ZodBoolean>;
+        destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            confidential: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        withdrawals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+        }, z.core.$strip>>>;
+        assets: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>;
+        owner_approval: z.ZodOptional<z.ZodBoolean>;
+        max_actions_per_hour: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        budget: z.ZodOptional<z.ZodObject<{
+            daily_usd: z.ZodNullable<z.ZodString>;
+            weekly_usd: z.ZodNullable<z.ZodString>;
+            monthly_usd: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        limits: z.ZodOptional<z.ZodObject<{
+            per_transaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            hourly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            daily: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            monthly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"approval_vote">;
+    approvalId: z.ZodUUID;
+    verdict: z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+    }>;
+    correlationId: z.ZodString;
+}, z.core.$strip>], "type">;
+export declare const ownerPrepareInput: z.ZodObject<{
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"agent_create">;
+        owner: z.ZodOptional<z.ZodObject<{
+            type: z.ZodLiteral<"near">;
+            account_id: z.ZodString;
+            public_key: z.ZodString;
+        }, z.core.$strip>>;
+        role: z.ZodOptional<z.ZodEnum<{
+            payout: "payout";
+            treasury: "treasury";
+        }>>;
+        payees: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"grant_issue">;
+        label: z.ZodOptional<z.ZodEnum<{
+            invoices: "invoices";
+            payout: "payout";
+            treasury: "treasury";
+        }>>;
+        suffix: z.ZodOptional<z.ZodString>;
+        expectedStrategyDigest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"grant_revoke">;
+        grantId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"agent_freeze">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"agent_unfreeze">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"policy_update">;
+        expectedPolicy: z.ZodObject<{
+            revision: z.ZodNumber;
+            digest: z.ZodString;
+        }, z.core.$strip>;
+        changes: z.ZodObject<{
+            swap: z.ZodOptional<z.ZodBoolean>;
+            destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                confidential: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            withdrawals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                address: z.ZodString;
+            }, z.core.$strip>>>;
+            assets: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>;
+            owner_approval: z.ZodOptional<z.ZodBoolean>;
+            max_actions_per_hour: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            budget: z.ZodOptional<z.ZodObject<{
+                daily_usd: z.ZodNullable<z.ZodString>;
+                weekly_usd: z.ZodNullable<z.ZodString>;
+                monthly_usd: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            limits: z.ZodOptional<z.ZodObject<{
+                per_transaction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                hourly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                daily: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                monthly: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"approval_vote">;
+        approvalId: z.ZodUUID;
+        verdict: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+        }>;
+        correlationId: z.ZodString;
+    }, z.core.$strip>], "type">;
+    signer: z.ZodEnum<{
+        dao: "dao";
+        wallet: "wallet";
+    }>;
+}, z.core.$strip>;
+/**
+ * A payout an app or owner asks for under its own `requestId`, stored before calling: the same request is sent at
+ * most once, and `payouts/status` answers it by `requestId`. A new attempt is a new `requestId`, after a refusal.
+ */
+export declare const payoutRequestId: z.ZodString;
+export declare const payoutRequestInput: z.ZodPipe<z.ZodObject<{
+    requestId: z.ZodString;
+    asset: z.ZodString;
+    delivery: z.ZodUnion<readonly [z.ZodLiteral<"intents">, z.ZodObject<{
+        chain: z.ZodString;
+    }, z.core.$strip>]>;
+    recipient: z.ZodString;
+    amount: z.ZodString;
+    expectedPolicy: z.ZodObject<{
+        revision: z.ZodNumber;
+        digest: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodTransform<{
+    requestId: string;
+    asset: string;
+    delivery: "intents" | {
+        chain: string;
+    };
+    recipient: string;
+    amount: string;
+    expectedPolicy: {
+        revision: number;
+        digest: string;
+    };
+}, {
+    requestId: string;
+    asset: string;
+    delivery: "intents" | {
+        chain: string;
+    };
+    recipient: string;
+    amount: string;
+    expectedPolicy: {
+        revision: number;
+        digest: string;
+    };
+}>>;
+export declare const payoutStatusInput: z.ZodObject<{
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/** A deposit address for the asset to fund (default USDC); wNEAR funds withdrawals that arrive as native NEAR. */
+export declare const depositInput: z.ZodOptional<z.ZodObject<{
+    asset: z.ZodOptional<z.ZodEnum<{
+        "nep141:17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1": "nep141:17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1";
+        "nep141:wrap.near": "nep141:wrap.near";
+    }>>;
+}, z.core.$strip>>;
+export declare const ownerSubmitInput: z.ZodObject<{
+    correlationId: z.ZodString;
+    signedData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const ownerStatusInput: z.ZodObject<{
+    correlationId: z.ZodString;
+}, z.core.$strip>;
+export declare const executePlanInput: z.ZodObject<{
+    planId: z.ZodUUID;
+}, z.core.$strip>;

package/dist/contract/inputs.js

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import { intentsAccount, isNearcomAddress, validIntentsAccount } from "./intents-account.js";
+/**
+ * Owner procedure inputs: the one source the server implements (src/rpc/*) and clients are typed from
+ * (owner-contract.ts). Pure schemas only, so the package stays browser-safe.
+ */
+export const run = z.object({ execute: z.boolean() });
+export const account = z.string().trim().min(2).max(64);
+// Only owner-entered Intents destinations: owner identities and provider evidence stay unchanged.
+export const transferAccount = z.string().transform(intentsAccount).refine(validIntentsAccount, "Enter a NEAR Intents account or nearcom: address");
+export const units = z.string().regex(/^[0-9]{1,40}$/, "an atomic integer amount");
+/** A NEAR account paid by withdrawal to chain `near`: never a `nearcom:` address, which is not on any chain. */
+export const nearAccount = z.string().trim().refine((value) => !isNearcomAddress(value) && validIntentsAccount(value), "Enter a NEAR account");
+/** A USD amount in the policy's budget; null leaves that window uncapped. */
+export const usdAmount = z.string().regex(/^\d+(\.\d+)?$/).nullable();
+/** Per-asset caps in raw units. */
+export const caps = z.record(z.string(), units);
+export const reviewedPolicy = z.object({ revision: z.number().int().nonnegative(), digest: z.string().regex(/^sha256:[0-9a-f]{64}$/) });
+const digest = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+/**
+ * What a grant's label says it is for: the agent's own strategies, its payouts, or invoices (the
+ * public invoice page). Each purpose (see authorize.ts) names the grant labels that may act for it.
+ */
+export const GRANT_LABELS = ["treasury", "payout", "invoices"];
+/** An owner action to prepare for signature (owner-intents.ts `prepare`). */
+export const ownerAction = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("agent_create"),
+        owner: z.object({ type: z.literal("near"), account_id: z.string(), public_key: z.string() }).optional(),
+        role: z.enum(["treasury", "payout"]).optional(),
+        payees: z.array(transferAccount).max(256).optional(),
+    }),
+    z.object({
+        type: z.literal("grant_issue"),
+        label: z.enum(GRANT_LABELS).optional(),
+        suffix: z.string().min(1).max(64).optional(),
+        expectedStrategyDigest: digest.optional(),
+    }),
+    z.object({ type: z.literal("grant_revoke"), grantId: z.string().min(1) }),
+    z.object({ type: z.literal("agent_freeze") }),
+    z.object({ type: z.literal("agent_unfreeze") }),
+    z.object({
+        type: z.literal("policy_update"),
+        expectedPolicy: reviewedPolicy,
+        changes: z.object({
+            swap: z.boolean().optional(),
+            destinations: z.array(z.object({ address: transferAccount, confidential: z.boolean() })).max(64).optional(),
+            /** NEAR accounts paid by withdrawal to chain `near` (no memo); withdrawals are on exactly while there is one. */
+            withdrawals: z.array(z.object({ address: nearAccount })).max(64).optional(),
+            assets: z.union([z.literal("any"), z.array(z.string())]).optional(),
+            owner_approval: z.boolean().optional(),
+            max_actions_per_hour: z.number().int().positive().nullable().optional(),
+            budget: z.object({ daily_usd: usdAmount, weekly_usd: usdAmount, monthly_usd: usdAmount }).optional(),
+            limits: z
+                .object({ per_transaction: caps, hourly: caps, daily: caps, monthly: caps })
+                .partial()
+                .optional(),
+        }),
+    }),
+    z.object({
+        type: z.literal("approval_vote"),
+        approvalId: z.uuid(),
+        verdict: z.enum(["approve", "reject"]),
+        correlationId: z.string(),
+    }),
+]);
+export const ownerPrepareInput = z.object({ action: ownerAction, signer: z.enum(["wallet", "dao"]) });
+/**
+ * A payout an app or owner asks for under its own `requestId`, stored before calling: the same request is sent at
+ * most once, and `payouts/status` answers it by `requestId`. A new attempt is a new `requestId`, after a refusal.
+ */
+export const payoutRequestId = z.string().regex(/^[A-Za-z0-9_-]{1,64}$/);
+export const payoutRequestInput = z.object({
+    requestId: payoutRequestId,
+    /** The token paid, as the provider names it (for example `nep141:…`). The agent's signed policy decides which are allowed. */
+    asset: z.string().min(1).max(256),
+    /**
+     * How it reaches the payee: `intents`, a confidential transfer inside NEAR Intents to an agreed payee (confidential
+     * USDC), or `{ chain: "near" }`, a withdrawal from the confidential balance to an agreed NEAR account (wNEAR arrives as
+     * native NEAR, or USDC). Other chains are refused before anything is recorded.
+     */
+    delivery: z.union([z.literal("intents"), z.object({ chain: z.string().min(1).max(64) })]),
+    /** A NEAR Intents account or `nearcom:` address for `intents`; a NEAR account for a withdrawal (never `nearcom:`). */
+    recipient: z.string().trim().min(1).max(80),
+    amount: units,
+    expectedPolicy: reviewedPolicy,
+}).superRefine((input, ctx) => {
+    const valid = input.delivery === "intents" ? validIntentsAccount(intentsAccount(input.recipient))
+        : !isNearcomAddress(input.recipient) && validIntentsAccount(input.recipient);
+    if (!valid)
+        ctx.addIssue({ code: "custom", path: ["recipient"],
+            message: input.delivery === "intents" ? "Enter a NEAR Intents account or nearcom: address" : "Enter a NEAR account: a nearcom: address is not on any chain" });
+}).transform((input) => input.delivery === "intents" ? { ...input, recipient: intentsAccount(input.recipient) } : input);
+export const payoutStatusInput = z.object({ requestId: payoutRequestId });
+/** A deposit address for the asset to fund (default USDC); wNEAR funds withdrawals that arrive as native NEAR. */
+export const depositInput = z.object({ asset: z.enum(["nep141:17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1", "nep141:wrap.near"]).optional() }).optional();
+export const ownerSubmitInput = z.object({ correlationId: z.string(), signedData: z.record(z.string(), z.unknown()) });
+export const ownerStatusInput = z.object({ correlationId: z.string() });
+export const executePlanInput = z.object({ planId: z.uuid() });

package/dist/contract/intents-account.d.ts

@@ -0,0 +1,5 @@
+/** near.com displays an Intents account with this prefix; the API takes the bare account. */
+export declare const isNearcomAddress: (value: string) => boolean;
+/** Normalize owner-entered transfer destinations, never signed/provider evidence or chain addresses. */
+export declare function intentsAccount(value: string): string;
+export declare const validIntentsAccount: (value: string) => boolean;

package/dist/contract/intents-account.js

@@ -0,0 +1,8 @@
+/** near.com displays an Intents account with this prefix; the API takes the bare account. */
+export const isNearcomAddress = (value) => /^nearcom:/i.test(value.trim());
+/** Normalize owner-entered transfer destinations, never signed/provider evidence or chain addresses. */
+export function intentsAccount(value) {
+    const trimmed = value.trim();
+    return isNearcomAddress(trimmed) ? trimmed.slice("nearcom:".length).toLowerCase() : trimmed;
+}
+export const validIntentsAccount = (value) => /^(?=.{2,64}$)[a-z0-9]+(?:[._-][a-z0-9]+)*$/.test(value);