@pear-protocol/types 2.7.0 → 2.10.0

package/dist/vaults/entities.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { EthereumAddress } from '../common/address';
+
+const VaultStatus = z.enum([
+  "active",
+  "inactive",
+  "pending_activation"
+]);
+const Vault = z.object({
+  id: z.string().uuid(),
+  vaultAddress: EthereumAddress,
+  ownerAddress: EthereumAddress,
+  traderAddress: EthereumAddress.nullable(),
+  agentAddress: EthereumAddress,
+  status: VaultStatus,
+  isApproved: z.boolean(),
+  name: z.string().nullable(),
+  about: z.string().nullable(),
+  imageUrl: z.string().nullable(),
+  transactionHash: z.string().nullable(),
+  maxWithdrawalPeriodDays: z.number().int(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+const Activity = z.object({
+  id: z.string(),
+  // Absent columns drop off the wire entirely rather than shipping as present nulls.
+  vaultAddress: z.string().optional(),
+  // Mirrors the vault_activity_type Postgres enum; duplicated literally because the SDK cannot import the database package.
+  type: z.enum([
+    "vault.create",
+    "vault.set_trader",
+    "vault.update_metadata",
+    "bridge.withdraw_to_evm"
+  ]),
+  status: z.enum([
+    "pending",
+    "succeeded",
+    "failed"
+  ]),
+  txHash: z.string().optional(),
+  error: z.string().optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime()
+});
+const VaultEvent = z.object({
+  id: z.string(),
+  vaultAddress: EthereumAddress,
+  eventType: z.enum([
+    "DEPOSIT",
+    "WITHDRAWAL"
+  ]),
+  userAddress: EthereumAddress,
+  receiver: EthereumAddress,
+  assets: z.string(),
+  shares: z.string(),
+  fee: z.string(),
+  withdrawalId: z.string().nullable(),
+  txHash: z.string(),
+  blockNumber: z.string(),
+  logIndex: z.number().int(),
+  createdAt: z.string().datetime()
+});
+const NavSnapshot = z.object({
+  vaultAddress: EthereumAddress,
+  takenAt: z.string().datetime(),
+  totalAssets: z.string(),
+  totalSupply: z.string(),
+  sharePrice: z.string(),
+  blockNumber: z.string()
+});
+const NavBucketPoint = z.object({
+  bucket: z.iso.datetime(),
+  totalAssets: z.string(),
+  totalSupply: z.string(),
+  sharePrice: z.string(),
+  blockNumber: z.string()
+});
+const BulkSnapshotPoint = z.object({
+  timestamp: z.number(),
+  createdAt: z.string(),
+  tvl: z.string().optional(),
+  sharePrice: z.string().optional(),
+  accountValue: z.null().optional(),
+  unrealizedPnl: z.null().optional(),
+  cumulativeRealizedPnl: z.null().optional(),
+  leaderSharePct: z.null().optional()
+});
+const SparklinePoint = z.object({
+  timestamp: z.number(),
+  createdAt: z.string(),
+  tvl: z.string(),
+  sharePrice: z.string()
+});
+
+export { Activity, BulkSnapshotPoint, NavBucketPoint, NavSnapshot, SparklinePoint, Vault, VaultEvent, VaultStatus };

package/dist/vaults/index.d.ts

@@ -0,0 +1,4 @@
+export * from './entities';
+export * from './payloads';
+export * from './queries';
+export * from './responses';

package/dist/vaults/index.js

@@ -0,0 +1,4 @@
+export * from './entities';
+export * from './payloads';
+export * from './queries';
+export * from './responses';

package/dist/vaults/payloads.d.ts

@@ -0,0 +1,140 @@
+import { z } from 'zod';
+import { EthereumAddress } from '../common/address';
+/** Positive decimal amount string, e.g. an withdrawal or approval size. */
+export declare const PositiveAmount: z.ZodString;
+/**
+ * Plane-2 leader-signature envelope carried by every leader-signed POST. LeaderSignatureGuard reads
+ * these fields from the raw body to recover the signer; replay defense is Restate idempotency keyed
+ * on the signature, and the client-minted nonce keeps two legitimate identical actions apart. The envelope carries
+ * auth only; every action-specific parameter is declared on the action's own schema and signed as a
+ * readable field of that action's own EIP-712 struct — the primary-type name discriminates the action.
+ */
+export declare const LeaderSignedAction: z.ZodObject<{
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Create is leader self-signed: the body extends the Plane-2 envelope so
+ * CreateSignatureGuard can recover the signer. Every create field is a readable
+ * field of the signed CreateVault struct.
+ */
+export declare const CreateVault: z.ZodObject<{
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodNumber;
+    leader: z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>;
+    name: z.ZodString;
+    description: z.ZodString;
+    imageUri: z.ZodOptional<z.ZodURL>;
+    configId: z.ZodNumber;
+    maxWithdrawalPeriodDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CreateVaultInput = z.input<typeof CreateVault>;
+export type CreateVault = z.infer<typeof CreateVault>;
+/**
+ * Set-trader is leader-signed: the body extends the Plane-2 envelope so
+ * LeaderSignatureGuard can recover the signer and enforce the deadline.
+ * The `traderAddress` is a readable field of the signed SetTrader struct.
+ */
+export declare const SetTrader: z.ZodObject<{
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodNumber;
+    traderAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>;
+}, z.core.$strict>;
+export type SetTraderInput = z.input<typeof SetTrader>;
+export type SetTrader = z.infer<typeof SetTrader>;
+/**
+ * Update-metadata is leader-signed: the body extends the Plane-2 envelope so
+ * LeaderSignatureGuard can recover the signer and enforce the deadline. The
+ * contract is the full display set — every field is sent and signed as a
+ * readable field of the UpdateVaultMetadata struct, because EIP-712 cannot
+ * express an omitted field. An empty string clears the optional columns.
+ */
+export declare const UpdateVaultMetadata: z.ZodObject<{
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodNumber;
+    name: z.ZodString;
+    about: z.ZodString;
+    imageUri: z.ZodUnion<readonly [z.ZodURL, z.ZodLiteral<"">]>;
+}, z.core.$strict>;
+export type UpdateVaultMetadataInput = z.input<typeof UpdateVaultMetadata>;
+export type UpdateVaultMetadata = z.infer<typeof UpdateVaultMetadata>;
+export declare const WithdrawToEvm: z.ZodObject<{
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodNumber;
+    amount: z.ZodString;
+    tokenId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WithdrawToEvmInput = z.input<typeof WithdrawToEvm>;
+export type WithdrawToEvm = z.infer<typeof WithdrawToEvm>;
+/**
+ * Agent-approve is leader-signed: the body carries only the Plane-2 envelope.
+ * The execution is fixed — maxUint256 on the vault's own asset — so there are no
+ * variable params to sign beyond the envelope; the primary-type name binds the action.
+ */
+export declare const AgentApprove: z.ZodObject<{
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodNumber;
+}, z.core.$strict>;
+export type AgentApproveInput = z.input<typeof AgentApprove>;
+export type AgentApprove = z.infer<typeof AgentApprove>;
+/**
+ * Set-unified-account is leader-signed: the body carries only the Plane-2 envelope.
+ * The execution is fixed — the vault's own agent — so there are no variable
+ * params to sign beyond the envelope; the primary-type name binds the action.
+ */
+export declare const SetUnifiedAccount: z.ZodObject<{
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodNumber;
+}, z.core.$strict>;
+export type SetUnifiedAccountInput = z.input<typeof SetUnifiedAccount>;
+export type SetUnifiedAccount = z.infer<typeof SetUnifiedAccount>;
+/** Builder-fee approval carried by the vault account provisioning workflow. */
+export declare const BuilderFeeApproval: z.ZodObject<{
+    builderAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>;
+    maxFeeRate: z.ZodCustom<`${string}%`, `${string}%`>;
+}, z.core.$strip>;
+export type BuilderFeeApproval = z.infer<typeof BuilderFeeApproval>;
+export declare const SnapshotsBulk: z.ZodObject<{
+    vaultAddresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>>;
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+    bucket: z.ZodEnum<{
+        "1d": "1d";
+        "1m": "1m";
+        "1h": "1h";
+        "5m": "5m";
+        "15m": "15m";
+    }>;
+    fields: z.ZodArray<z.ZodEnum<{
+        unrealizedPnl: "unrealizedPnl";
+        sharePrice: "sharePrice";
+        tvl: "tvl";
+        accountValue: "accountValue";
+        cumulativeRealizedPnl: "cumulativeRealizedPnl";
+        leaderSharePct: "leaderSharePct";
+    }>>;
+}, z.core.$strict>;
+export type SnapshotsBulkInput = z.input<typeof SnapshotsBulk>;
+export type SnapshotsBulk = z.infer<typeof SnapshotsBulk>;
+/**
+ * EIP-712 typed data envelope, in the shape the JSON-RPC `eth_signTypedData_v4`
+ * (and Privy's `signTypedData`) expects. Built inside the service from admitted
+ * actions; never accepted as a caller-supplied signing envelope.
+ */
+export declare const TypedDataPayload: z.ZodObject<{
+    domain: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    types: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>>;
+    primaryType: z.ZodString;
+    message: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type TypedDataPayload = z.infer<typeof TypedDataPayload>;

package/dist/vaults/payloads.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { EthereumAddress } from '../common/address';
+import { NavBucket } from './queries';
+
+const PositiveAmount = z.string().regex(/^\d+(\.\d+)?$/).refine((amount) => /[1-9]/.test(amount), "Amount must be positive");
+const LeaderSignedAction = z.object({
+  signature: z.string().regex(/^0x[0-9a-fA-F]{130}$/),
+  nonce: z.string().min(1),
+  deadline: z.number().int().positive()
+});
+const CreateVault = LeaderSignedAction.extend({
+  leader: EthereumAddress,
+  name: z.string().min(1).max(255),
+  description: z.string(),
+  imageUri: z.url().optional(),
+  configId: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  maxWithdrawalPeriodDays: z.number().int().min(1).optional()
+}).strict();
+const SetTrader = LeaderSignedAction.extend({
+  traderAddress: EthereumAddress
+}).strict();
+const UpdateVaultMetadata = LeaderSignedAction.extend({
+  name: z.string().min(1).max(255),
+  about: z.string(),
+  imageUri: z.union([
+    z.url(),
+    z.literal("")
+  ])
+}).strict();
+const WithdrawToEvm = LeaderSignedAction.extend({
+  amount: PositiveAmount.refine((amount) => (amount.split(".")[1]?.length ?? 0) <= 6, "USDC supports six decimal places"),
+  tokenId: z.string().optional()
+}).strict();
+const AgentApprove = LeaderSignedAction.strict();
+const SetUnifiedAccount = LeaderSignedAction.strict();
+const BuilderFeeApproval = z.object({
+  builderAddress: EthereumAddress,
+  // Typed as the percent literal Hyperliquid's SDK demands; the predicate is the same rule the regex enforced.
+  maxFeeRate: z.custom((value) => typeof value === "string" && /^\d*\.?\d+%$/.test(value))
+});
+const SnapshotsBulk = z.object({
+  vaultAddresses: z.array(EthereumAddress).min(1).max(50),
+  startDate: z.string().regex(/^\d+$/).refine((value) => Number(value) <= 864e10),
+  endDate: z.string().regex(/^\d+$/).refine((value) => Number(value) <= 864e10),
+  bucket: NavBucket,
+  fields: z.array(z.enum([
+    "tvl",
+    "sharePrice",
+    "accountValue",
+    "unrealizedPnl",
+    "cumulativeRealizedPnl",
+    "leaderSharePct"
+  ])).min(1)
+}).strict().refine((value) => Number(value.startDate) <= Number(value.endDate), "startDate must precede endDate");
+const TypedDataPayload = z.object({
+  domain: z.record(z.string(), z.unknown()),
+  types: z.record(z.string(), z.array(z.object({
+    name: z.string(),
+    type: z.string()
+  }))),
+  primaryType: z.string().min(1),
+  message: z.record(z.string(), z.unknown())
+}).strict();
+
+export { AgentApprove, BuilderFeeApproval, CreateVault, LeaderSignedAction, PositiveAmount, SetTrader, SetUnifiedAccount, SnapshotsBulk, TypedDataPayload, UpdateVaultMetadata, WithdrawToEvm };

package/dist/vaults/queries.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { EthereumAddress } from '../common/address';
+export declare const VaultListParams: z.ZodObject<{
+    owner: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>>;
+    trader: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>>;
+    name: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strict>;
+export type VaultListParamsInput = z.input<typeof VaultListParams>;
+export type VaultListParams = z.infer<typeof VaultListParams>;
+export declare const NavBucket: z.ZodEnum<{
+    "1d": "1d";
+    "1m": "1m";
+    "1h": "1h";
+    "5m": "5m";
+    "15m": "15m";
+}>;
+export type NavBucket = z.infer<typeof NavBucket>;
+export declare const SparklineRange: z.ZodEnum<{
+    "1h": "1h";
+    "24h": "24h";
+    "7d": "7d";
+    "30d": "30d";
+}>;
+export type SparklineRange = z.infer<typeof SparklineRange>;
+export declare const VaultsOverviewQueryParams: z.ZodObject<{
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    pageSize: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    sparklineRange: z.ZodDefault<z.ZodEnum<{
+        "1h": "1h";
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+    }>>;
+    sparklineBucket: z.ZodDefault<z.ZodEnum<{
+        "1d": "1d";
+        "1m": "1m";
+        "1h": "1h";
+        "5m": "5m";
+        "15m": "15m";
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type VaultsOverviewQueryParamsInput = z.input<typeof VaultsOverviewQueryParams>;
+export type VaultsOverviewQueryParams = z.output<typeof VaultsOverviewQueryParams>;
+export declare const VaultStatsQueryParams: z.ZodObject<{
+    address: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>>;
+}, z.core.$strict>;
+export type VaultStatsQueryParamsInput = z.input<typeof VaultStatsQueryParams>;
+export type VaultStatsQueryParams = z.output<typeof VaultStatsQueryParams>;
+export declare const VaultInvestmentsQueryParams: z.ZodObject<{
+    address: z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>;
+}, z.core.$strict>;
+export type VaultInvestmentsQueryParamsInput = z.input<typeof VaultInvestmentsQueryParams>;
+export type VaultInvestmentsQueryParams = z.output<typeof VaultInvestmentsQueryParams>;
+export declare const NavResolution: z.ZodEnum<{
+    "1d": "1d";
+    "1m": "1m";
+    "1h": "1h";
+    "5m": "5m";
+}>;
+export type NavResolution = z.infer<typeof NavResolution>;
+export declare const NavStatsWindow: z.ZodEnum<{
+    "24h": "24h";
+    "7d": "7d";
+    "30d": "30d";
+}>;
+export type NavStatsWindow = z.infer<typeof NavStatsWindow>;
+export declare const NavRangeQueryParams: z.ZodObject<{
+    from: z.ZodISODateTime;
+    to: z.ZodISODateTime;
+    resolution: z.ZodDefault<z.ZodEnum<{
+        "1d": "1d";
+        "1m": "1m";
+        "1h": "1h";
+        "5m": "5m";
+    }>>;
+}, z.core.$strict>;
+export type NavRangeQueryParamsInput = z.input<typeof NavRangeQueryParams>;
+export type NavRangeQueryParams = z.output<typeof NavRangeQueryParams>;
+export declare const NavStatsQueryParams: z.ZodObject<{
+    window: z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+    }>;
+}, z.core.$strict>;
+export type NavStatsQueryParams = z.infer<typeof NavStatsQueryParams>;
+export declare const VaultEventListParams: z.ZodObject<{
+    userAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type VaultEventListParamsInput = z.input<typeof VaultEventListParams>;
+export type VaultEventListParams = z.infer<typeof VaultEventListParams>;

package/dist/vaults/queries.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { EthereumAddress } from '../common/address';
+
+const VaultListParams = z.object({
+  owner: EthereumAddress.optional(),
+  trader: EthereumAddress.optional(),
+  name: z.string().max(200).optional(),
+  limit: z.coerce.number().int().min(1).max(200).optional(),
+  cursor: z.uuid().optional()
+}).strict();
+const NavBucket = z.enum([
+  "1m",
+  "5m",
+  "15m",
+  "1h",
+  "1d"
+]);
+const SparklineRange = z.enum([
+  "1h",
+  "24h",
+  "7d",
+  "30d"
+]);
+const VaultsOverviewQueryParams = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).default(100),
+  sparklineRange: SparklineRange.default("24h"),
+  sparklineBucket: NavBucket.default("1h"),
+  name: z.string().optional()
+}).strict();
+const VaultStatsQueryParams = z.object({
+  address: EthereumAddress.optional()
+}).strict();
+const VaultInvestmentsQueryParams = z.object({
+  address: EthereumAddress
+}).strict();
+const NavResolution = z.enum([
+  "1m",
+  "5m",
+  "1h",
+  "1d"
+]);
+const NavStatsWindow = z.enum([
+  "24h",
+  "7d",
+  "30d"
+]);
+const NavRangeQueryParams = z.object({
+  from: z.iso.datetime({
+    offset: true
+  }),
+  to: z.iso.datetime({
+    offset: true
+  }),
+  resolution: NavResolution.default("1m")
+}).strict().refine((query) => new Date(query.from) <= new Date(query.to), "from must precede to");
+const NavStatsQueryParams = z.object({
+  window: NavStatsWindow
+}).strict();
+const VaultEventListParams = z.object({
+  userAddress: EthereumAddress.optional(),
+  limit: z.coerce.number().int().min(1).max(1e3).optional(),
+  offset: z.coerce.number().int().min(0).optional()
+}).strict();
+
+export { NavBucket, NavRangeQueryParams, NavResolution, NavStatsQueryParams, NavStatsWindow, SparklineRange, VaultEventListParams, VaultInvestmentsQueryParams, VaultListParams, VaultStatsQueryParams, VaultsOverviewQueryParams };