@augustdigital/config 0.1.0

package/lib/profile.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveProfile = saveProfile;
+exports.loadProfile = loadProfile;
+exports.listProfiles = listProfiles;
+exports.deleteProfile = deleteProfile;
+const node_fs_1 = require("node:fs");
+const zod_1 = require("zod");
+const errors_1 = require("./errors");
+const paths_1 = require("./paths");
+const ProfileSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(1).default(1),
+    name: zod_1.z.string().min(1),
+    defaultChainId: zod_1.z.number().int().optional(),
+    rpcs: zod_1.z.record(zod_1.z.string().min(1), zod_1.z.string().url()).default({}),
+    notes: zod_1.z.string().optional(),
+});
+function saveProfile(profile) {
+    const validated = ProfileSchema.parse(profile);
+    if (validated.name.includes('/') || validated.name.includes('\\')) {
+        throw new errors_1.AugustConfigError('PROFILE_INVALID', `Profile name "${validated.name}" may not contain path separators.`);
+    }
+    const dir = (0, paths_1.profilesDir)();
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true, mode: 0o700 });
+    }
+    (0, node_fs_1.writeFileSync)((0, paths_1.profileFile)(validated.name), JSON.stringify(validated, null, 2), {
+        encoding: 'utf8',
+        mode: 0o644,
+    });
+    return validated;
+}
+function loadProfile(name) {
+    const path = (0, paths_1.profileFile)(name);
+    if (!(0, node_fs_1.existsSync)(path)) {
+        throw new errors_1.AugustConfigError('PROFILE_NOT_FOUND', `No profile named "${name}" (looked at ${path}).`, 'Run `august profile list` to see available profiles.');
+    }
+    let raw;
+    try {
+        raw = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+    }
+    catch (err) {
+        throw new errors_1.AugustConfigError('PROFILE_INVALID', `Profile "${name}" is not valid JSON: ${err.message}`);
+    }
+    const result = ProfileSchema.safeParse(raw);
+    if (!result.success) {
+        throw new errors_1.AugustConfigError('PROFILE_INVALID', `Profile "${name}" failed validation: ${result.error.message}`);
+    }
+    return result.data;
+}
+function listProfiles() {
+    const dir = (0, paths_1.profilesDir)();
+    if (!(0, node_fs_1.existsSync)(dir))
+        return [];
+    return (0, node_fs_1.readdirSync)(dir)
+        .filter((f) => f.endsWith('.json'))
+        .map((f) => f.replace(/\.json$/, ''))
+        .sort();
+}
+function deleteProfile(name) {
+    const path = (0, paths_1.profileFile)(name);
+    if ((0, node_fs_1.existsSync)(path))
+        (0, node_fs_1.unlinkSync)(path);
+}
+//# sourceMappingURL=profile.js.map

package/lib/schemas/envelope.d.ts

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+export declare const ResultMetaSchema: z.ZodObject<{
+    chainId: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    generatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    chainId?: number;
+    durationMs?: number;
+    generatedAt?: string;
+}, {
+    chainId?: number;
+    durationMs?: number;
+    generatedAt?: string;
+}>;
+export type ResultMeta = z.infer<typeof ResultMetaSchema>;
+export declare const ResultErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    remediation: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code?: string;
+    message?: string;
+    remediation?: string;
+}, {
+    code?: string;
+    message?: string;
+    remediation?: string;
+}>;
+export type ResultError = z.infer<typeof ResultErrorSchema>;
+export declare function envelope<T extends z.ZodTypeAny>(data: T): z.ZodDiscriminatedUnion<"ok", [z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    command: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    data: T;
+    meta: z.ZodObject<{
+        chainId: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        generatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    }, {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    }>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    schemaVersion: z.ZodLiteral<1>;
+    command: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    data: T;
+    meta: z.ZodObject<{
+        chainId: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        generatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    }, {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    }>;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    schemaVersion: z.ZodLiteral<1>;
+    command: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    data: T;
+    meta: z.ZodObject<{
+        chainId: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        generatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    }, {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    }>;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    command: z.ZodString;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        remediation: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code?: string;
+        message?: string;
+        remediation?: string;
+    }, {
+        code?: string;
+        message?: string;
+        remediation?: string;
+    }>;
+    meta: z.ZodObject<{
+        chainId: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        generatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    }, {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion?: 1;
+    ok?: false;
+    command?: string;
+    meta?: {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    };
+    error?: {
+        code?: string;
+        message?: string;
+        remediation?: string;
+    };
+}, {
+    schemaVersion?: 1;
+    ok?: false;
+    command?: string;
+    meta?: {
+        chainId?: number;
+        durationMs?: number;
+        generatedAt?: string;
+    };
+    error?: {
+        code?: string;
+        message?: string;
+        remediation?: string;
+    };
+}>]>;
+export type Envelope<TData> = {
+    schemaVersion: 1;
+    command: string;
+    ok: true;
+    data: TData;
+    meta: ResultMeta;
+} | {
+    schemaVersion: 1;
+    command: string;
+    ok: false;
+    error: ResultError;
+    meta: ResultMeta;
+};

package/lib/schemas/envelope.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultErrorSchema = exports.ResultMetaSchema = void 0;
+exports.envelope = envelope;
+const zod_1 = require("zod");
+exports.ResultMetaSchema = zod_1.z.object({
+    chainId: zod_1.z.number().int().optional(),
+    durationMs: zod_1.z.number().nonnegative().optional(),
+    generatedAt: zod_1.z.string().datetime(),
+});
+exports.ResultErrorSchema = zod_1.z.object({
+    code: zod_1.z.string(),
+    message: zod_1.z.string(),
+    remediation: zod_1.z.string().optional(),
+});
+function envelope(data) {
+    return zod_1.z.discriminatedUnion('ok', [
+        zod_1.z.object({
+            schemaVersion: zod_1.z.literal(1),
+            command: zod_1.z.string(),
+            ok: zod_1.z.literal(true),
+            data,
+            meta: exports.ResultMetaSchema,
+        }),
+        zod_1.z.object({
+            schemaVersion: zod_1.z.literal(1),
+            command: zod_1.z.string(),
+            ok: zod_1.z.literal(false),
+            error: exports.ResultErrorSchema,
+            meta: exports.ResultMetaSchema,
+        }),
+    ]);
+}
+//# sourceMappingURL=envelope.js.map

package/lib/schemas/index.d.ts

@@ -0,0 +1,4 @@
+export * from './envelope';
+export * from './vault';
+export * from './user';
+export * from './meta';

package/lib/schemas/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./envelope"), exports);
+__exportStar(require("./vault"), exports);
+__exportStar(require("./user"), exports);
+__exportStar(require("./meta"), exports);
+//# sourceMappingURL=index.js.map

package/lib/schemas/meta.d.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+export declare const ChainListSchema: z.ZodObject<{
+    chains: z.ZodArray<z.ZodObject<{
+        chainId: z.ZodNumber;
+        name: z.ZodString;
+        explorer: z.ZodOptional<z.ZodString>;
+        hasRpc: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        chainId?: number;
+        explorer?: string;
+        hasRpc?: boolean;
+    }, {
+        name?: string;
+        chainId?: number;
+        explorer?: string;
+        hasRpc?: boolean;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    chains?: {
+        name?: string;
+        chainId?: number;
+        explorer?: string;
+        hasRpc?: boolean;
+    }[];
+}, {
+    chains?: {
+        name?: string;
+        chainId?: number;
+        explorer?: string;
+        hasRpc?: boolean;
+    }[];
+}>;
+export type ChainList = z.infer<typeof ChainListSchema>;
+export declare const RpcTestSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        chainId: z.ZodNumber;
+        url: z.ZodOptional<z.ZodString>;
+        ok: z.ZodBoolean;
+        latencyMs: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url?: string;
+        chainId?: number;
+        ok?: boolean;
+        error?: string;
+        latencyMs?: number;
+    }, {
+        url?: string;
+        chainId?: number;
+        ok?: boolean;
+        error?: string;
+        latencyMs?: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    results?: {
+        url?: string;
+        chainId?: number;
+        ok?: boolean;
+        error?: string;
+        latencyMs?: number;
+    }[];
+}, {
+    results?: {
+        url?: string;
+        chainId?: number;
+        ok?: boolean;
+        error?: string;
+        latencyMs?: number;
+    }[];
+}>;
+export type RpcTest = z.infer<typeof RpcTestSchema>;
+export declare const WhoamiSchema: z.ZodObject<{
+    profile: z.ZodString;
+    defaultChainId: z.ZodNumber;
+    configDir: z.ZodString;
+    cliVersion: z.ZodOptional<z.ZodString>;
+    sdkVersion: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodObject<{
+        present: z.ZodBoolean;
+        source: z.ZodEnum<["env", "session", "flag", "none"]>;
+        sessionExpiresAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        present?: boolean;
+        source?: "flag" | "env" | "session" | "none";
+        sessionExpiresAt?: string;
+    }, {
+        present?: boolean;
+        source?: "flag" | "env" | "session" | "none";
+        sessionExpiresAt?: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    defaultChainId?: number;
+    apiKey?: {
+        present?: boolean;
+        source?: "flag" | "env" | "session" | "none";
+        sessionExpiresAt?: string;
+    };
+    profile?: string;
+    configDir?: string;
+    cliVersion?: string;
+    sdkVersion?: string;
+}, {
+    defaultChainId?: number;
+    apiKey?: {
+        present?: boolean;
+        source?: "flag" | "env" | "session" | "none";
+        sessionExpiresAt?: string;
+    };
+    profile?: string;
+    configDir?: string;
+    cliVersion?: string;
+    sdkVersion?: string;
+}>;
+export type Whoami = z.infer<typeof WhoamiSchema>;

package/lib/schemas/meta.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhoamiSchema = exports.RpcTestSchema = exports.ChainListSchema = void 0;
+const zod_1 = require("zod");
+exports.ChainListSchema = zod_1.z.object({
+    chains: zod_1.z.array(zod_1.z.object({
+        chainId: zod_1.z.number().int(),
+        name: zod_1.z.string(),
+        explorer: zod_1.z.string().url().optional(),
+        hasRpc: zod_1.z.boolean(),
+    })),
+});
+exports.RpcTestSchema = zod_1.z.object({
+    results: zod_1.z.array(zod_1.z.object({
+        chainId: zod_1.z.number().int(),
+        url: zod_1.z.string().url().optional(),
+        ok: zod_1.z.boolean(),
+        latencyMs: zod_1.z.number().nonnegative().optional(),
+        error: zod_1.z.string().optional(),
+    })),
+});
+exports.WhoamiSchema = zod_1.z.object({
+    profile: zod_1.z.string(),
+    defaultChainId: zod_1.z.number().int(),
+    configDir: zod_1.z.string(),
+    cliVersion: zod_1.z.string().optional(),
+    sdkVersion: zod_1.z.string().optional(),
+    apiKey: zod_1.z.object({
+        present: zod_1.z.boolean(),
+        source: zod_1.z.enum(['env', 'session', 'flag', 'none']),
+        sessionExpiresAt: zod_1.z.string().datetime().optional(),
+    }),
+});
+//# sourceMappingURL=meta.js.map

package/lib/schemas/user.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+export declare const UserPointsSchema: z.ZodObject<{
+    user: z.ZodString;
+    total: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    rank: z.ZodOptional<z.ZodNumber>;
+    breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    user: z.ZodString;
+    total: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    rank: z.ZodOptional<z.ZodNumber>;
+    breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    user: z.ZodString;
+    total: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    rank: z.ZodOptional<z.ZodNumber>;
+    breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type UserPoints = z.infer<typeof UserPointsSchema>;
+export declare const UserPositionsSchema: z.ZodObject<{
+    user: z.ZodString;
+    positions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    user: z.ZodString;
+    positions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    user: z.ZodString;
+    positions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        shares: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        assets: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        apy: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, z.ZodTypeAny, "passthrough">>;
+export type UserPositions = z.infer<typeof UserPositionsSchema>;
+export declare const UserPnlSchema: z.ZodObject<{
+    user: z.ZodString;
+    lifetime: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    perVault: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    user: z.ZodString;
+    lifetime: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    perVault: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    user: z.ZodString;
+    lifetime: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    perVault: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        vault: z.ZodString;
+        chainId: z.ZodNumber;
+        pnl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, z.ZodTypeAny, "passthrough">>;
+export type UserPnl = z.infer<typeof UserPnlSchema>;

package/lib/schemas/user.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPnlSchema = exports.UserPositionsSchema = exports.UserPointsSchema = void 0;
+const zod_1 = require("zod");
+const Address = zod_1.z
+    .string()
+    .regex(/^(0x[0-9a-fA-F]{40}|[1-9A-HJ-NP-Za-km-z]{32,44})$/);
+const BigNumeric = zod_1.z.union([zod_1.z.string(), zod_1.z.number()]);
+exports.UserPointsSchema = zod_1.z
+    .object({
+    user: Address,
+    total: BigNumeric.optional(),
+    rank: zod_1.z.number().int().optional(),
+    breakdown: zod_1.z.record(zod_1.z.string(), BigNumeric).optional(),
+})
+    .passthrough();
+exports.UserPositionsSchema = zod_1.z
+    .object({
+    user: Address,
+    positions: zod_1.z
+        .array(zod_1.z
+        .object({
+        vault: Address,
+        chainId: zod_1.z.number().int(),
+        shares: BigNumeric,
+        assets: BigNumeric.optional(),
+        apy: zod_1.z.number().optional(),
+    })
+        .passthrough())
+        .default([]),
+})
+    .passthrough();
+exports.UserPnlSchema = zod_1.z
+    .object({
+    user: Address,
+    lifetime: BigNumeric.optional(),
+    perVault: zod_1.z
+        .array(zod_1.z
+        .object({
+        vault: Address,
+        chainId: zod_1.z.number().int(),
+        pnl: BigNumeric.optional(),
+    })
+        .passthrough())
+        .default([]),
+})
+    .passthrough();
+//# sourceMappingURL=user.js.map