@compass-labs/api-sdk 2.2.105 → 2.2.106

package/src/models/components/riskyieldswaprequest.ts

@@ -0,0 +1,178 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Risk Yield is available on Robinhood Chain only.
+ */
+export const RiskYieldSwapRequestChain = {
+  Robinhood: "robinhood",
+} as const;
+/**
+ * Risk Yield is available on Robinhood Chain only.
+ */
+export type RiskYieldSwapRequestChain = ClosedEnum<
+  typeof RiskYieldSwapRequestChain
+>;
+
+/**
+ * How far the executed amounts may fall short of the quote before the transaction reverts. Memecoin pools move between the quote and the block that includes the transaction.
+ */
+export type RiskYieldSwapRequestSlippagePct = number | string;
+
+/**
+ * In token units, not wei.
+ */
+export type RiskYieldSwapRequestAmountIn = number | string;
+
+/**
+ * Swap one token for another from inside the Risk Yield Account.
+ *
+ * @remarks
+ *
+ * There is no aggregator on this chain, so the route is a Uniswap v3 pool.
+ * The API quotes every enabled fee tier and takes whichever returns the most —
+ * a 1% pool with depth beats a 0.05% pool with none, and here that is the
+ * common case.
+ */
+export type RiskYieldSwapRequest = {
+  /**
+   * The wallet that owns the Risk Yield Account.
+   */
+  owner: string;
+  /**
+   * Risk Yield is available on Robinhood Chain only.
+   */
+  chain?: RiskYieldSwapRequestChain | undefined;
+  /**
+   * Return EIP-712 typed data for the owner to sign instead of a transaction, so a sponsor can broadcast it.
+   */
+  gasSponsorship?: boolean | undefined;
+  /**
+   * Return the plan and its simulation without building a transaction. Nothing is signed and nothing can be broadcast.
+   */
+  preview?: boolean | undefined;
+  /**
+   * How far the executed amounts may fall short of the quote before the transaction reverts. Memecoin pools move between the quote and the block that includes the transaction.
+   */
+  slippagePct?: number | string | undefined;
+  /**
+   * How long the transaction stays valid once built.
+   */
+  deadlineSeconds?: number | undefined;
+  /**
+   * What you are spending.
+   */
+  tokenIn: string;
+  /**
+   * What you want.
+   */
+  tokenOut: string;
+  /**
+   * In token units, not wei.
+   */
+  amountIn: number | string;
+  /**
+   * Pin the route to one fee tier. Leave unset to let the API pick the tier that returns the most.
+   */
+  feePpm?: number | null | undefined;
+};
+
+/** @internal */
+export const RiskYieldSwapRequestChain$outboundSchema: z.ZodNativeEnum<
+  typeof RiskYieldSwapRequestChain
+> = z.nativeEnum(RiskYieldSwapRequestChain);
+
+/** @internal */
+export type RiskYieldSwapRequestSlippagePct$Outbound = number | string;
+
+/** @internal */
+export const RiskYieldSwapRequestSlippagePct$outboundSchema: z.ZodType<
+  RiskYieldSwapRequestSlippagePct$Outbound,
+  z.ZodTypeDef,
+  RiskYieldSwapRequestSlippagePct
+> = z.union([z.number(), z.string()]);
+
+export function riskYieldSwapRequestSlippagePctToJSON(
+  riskYieldSwapRequestSlippagePct: RiskYieldSwapRequestSlippagePct,
+): string {
+  return JSON.stringify(
+    RiskYieldSwapRequestSlippagePct$outboundSchema.parse(
+      riskYieldSwapRequestSlippagePct,
+    ),
+  );
+}
+
+/** @internal */
+export type RiskYieldSwapRequestAmountIn$Outbound = number | string;
+
+/** @internal */
+export const RiskYieldSwapRequestAmountIn$outboundSchema: z.ZodType<
+  RiskYieldSwapRequestAmountIn$Outbound,
+  z.ZodTypeDef,
+  RiskYieldSwapRequestAmountIn
+> = z.union([z.number(), z.string()]);
+
+export function riskYieldSwapRequestAmountInToJSON(
+  riskYieldSwapRequestAmountIn: RiskYieldSwapRequestAmountIn,
+): string {
+  return JSON.stringify(
+    RiskYieldSwapRequestAmountIn$outboundSchema.parse(
+      riskYieldSwapRequestAmountIn,
+    ),
+  );
+}
+
+/** @internal */
+export type RiskYieldSwapRequest$Outbound = {
+  owner: string;
+  chain?: string | undefined;
+  gas_sponsorship?: boolean | undefined;
+  preview?: boolean | undefined;
+  slippage_pct?: number | string | undefined;
+  deadline_seconds?: number | undefined;
+  token_in: string;
+  token_out: string;
+  amount_in: number | string;
+  fee_ppm?: number | null | undefined;
+};
+
+/** @internal */
+export const RiskYieldSwapRequest$outboundSchema: z.ZodType<
+  RiskYieldSwapRequest$Outbound,
+  z.ZodTypeDef,
+  RiskYieldSwapRequest
+> = z.object({
+  owner: z.string(),
+  chain: RiskYieldSwapRequestChain$outboundSchema.optional(),
+  gasSponsorship: z.boolean().optional(),
+  preview: z.boolean().optional(),
+  slippagePct: z.union([z.number(), z.string()]).optional(),
+  deadlineSeconds: z.number().int().optional(),
+  tokenIn: z.string(),
+  tokenOut: z.string(),
+  amountIn: z.union([z.number(), z.string()]),
+  feePpm: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    gasSponsorship: "gas_sponsorship",
+    slippagePct: "slippage_pct",
+    deadlineSeconds: "deadline_seconds",
+    tokenIn: "token_in",
+    tokenOut: "token_out",
+    amountIn: "amount_in",
+    feePpm: "fee_ppm",
+  });
+});
+
+export function riskYieldSwapRequestToJSON(
+  riskYieldSwapRequest: RiskYieldSwapRequest,
+): string {
+  return JSON.stringify(
+    RiskYieldSwapRequest$outboundSchema.parse(riskYieldSwapRequest),
+  );
+}

package/src/models/components/riskyieldswapresponse.ts

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { PlanStep, PlanStep$inboundSchema } from "./planstep.js";
+import { Simulation, Simulation$inboundSchema } from "./simulation.js";
+import { SwapPlan, SwapPlan$inboundSchema } from "./swapplan.js";
+import {
+  UnsignedTransaction,
+  UnsignedTransaction$inboundSchema,
+} from "./unsignedtransaction.js";
+
+export type RiskYieldSwapResponse = {
+  /**
+   * Null when `preview` was set, or when the plan is a no-op.
+   */
+  transaction?: UnsignedTransaction | null | undefined;
+  swap?: SwapPlan | null | undefined;
+  /**
+   * What the single transaction does, in order.
+   */
+  steps?: Array<PlanStep> | undefined;
+  /**
+   * The result of executing this against current state. A failure here is the only warning you get about a token that taxes transfers, blocks an address, or is paused.
+   */
+  simulation?: Simulation | null | undefined;
+  warnings?: Array<string> | undefined;
+};
+
+/** @internal */
+export const RiskYieldSwapResponse$inboundSchema: z.ZodType<
+  RiskYieldSwapResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  transaction: z.nullable(UnsignedTransaction$inboundSchema).optional(),
+  swap: z.nullable(SwapPlan$inboundSchema).optional(),
+  steps: z.array(PlanStep$inboundSchema).optional(),
+  simulation: z.nullable(Simulation$inboundSchema).optional(),
+  warnings: z.array(z.string()).optional(),
+});
+
+export function riskYieldSwapResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<RiskYieldSwapResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RiskYieldSwapResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RiskYieldSwapResponse' from JSON`,
+  );
+}

package/src/models/components/riskyieldtransferrequest.ts

@@ -0,0 +1,154 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Risk Yield is available on Robinhood Chain only.
+ */
+export const RiskYieldTransferRequestChain = {
+  Robinhood: "robinhood",
+} as const;
+/**
+ * Risk Yield is available on Robinhood Chain only.
+ */
+export type RiskYieldTransferRequestChain = ClosedEnum<
+  typeof RiskYieldTransferRequestChain
+>;
+
+/**
+ * The amount of 'token' to transfer.
+ */
+export type RiskYieldTransferRequestAmount = number | string;
+
+/**
+ * Whether you are depositing to or withdrawing from your earn account.
+ */
+export const RiskYieldTransferRequestAction = {
+  Deposit: "DEPOSIT",
+  Withdraw: "WITHDRAW",
+} as const;
+/**
+ * Whether you are depositing to or withdrawing from your earn account.
+ */
+export type RiskYieldTransferRequestAction = ClosedEnum<
+  typeof RiskYieldTransferRequestAction
+>;
+
+/**
+ * Deposit into, or withdraw from, the Risk Yield Account.
+ *
+ * @remarks
+ *
+ * The Risk Yield Account *is* the Earn Account on this chain, so this is the
+ * Earn transfer with the chain pinned. Sharing the implementation is
+ * deliberate: two transfer paths into one Safe would be two chances to get a
+ * balance check wrong.
+ */
+export type RiskYieldTransferRequest = {
+  /**
+   * The owner's wallet address.
+   */
+  owner: string;
+  /**
+   * Risk Yield is available on Robinhood Chain only.
+   */
+  chain?: RiskYieldTransferRequestChain | undefined;
+  /**
+   * The token you would like to transfer.
+   */
+  token: string;
+  /**
+   * The amount of 'token' to transfer.
+   */
+  amount: number | string;
+  /**
+   * Whether you are depositing to or withdrawing from your earn account.
+   */
+  action: RiskYieldTransferRequestAction;
+  /**
+   * Optionally request gas sponsorship. If set to `true`, EIP-712 signature data will be returned that must be signed by the `owner` and submitted to the `/gas_sponsorship/prepare` endpoint.
+   */
+  gasSponsorship?: boolean | undefined;
+  /**
+   * The address that will call Permit2's permitTransferFrom to execute the transfer. When `action` is 'DEPOSIT' and `gas_sponsorship` is `true`: - If provided, the signature will authorize this address (typically a gas sponsor) to pull tokens. - If not provided, defaults to the Earn Account (Safe) address, allowing the transfer to be included in a bundle transaction where the Safe pulls the tokens itself.
+   */
+  spender?: string | null | undefined;
+  /**
+   * Optional recipient address for withdrawals. When `action` is 'WITHDRAW': - If provided, tokens will be sent to this address instead of the owner. - If not provided, defaults to the owner's address.
+   */
+  recipient?: string | null | undefined;
+};
+
+/** @internal */
+export const RiskYieldTransferRequestChain$outboundSchema: z.ZodNativeEnum<
+  typeof RiskYieldTransferRequestChain
+> = z.nativeEnum(RiskYieldTransferRequestChain);
+
+/** @internal */
+export type RiskYieldTransferRequestAmount$Outbound = number | string;
+
+/** @internal */
+export const RiskYieldTransferRequestAmount$outboundSchema: z.ZodType<
+  RiskYieldTransferRequestAmount$Outbound,
+  z.ZodTypeDef,
+  RiskYieldTransferRequestAmount
+> = z.union([z.number(), z.string()]);
+
+export function riskYieldTransferRequestAmountToJSON(
+  riskYieldTransferRequestAmount: RiskYieldTransferRequestAmount,
+): string {
+  return JSON.stringify(
+    RiskYieldTransferRequestAmount$outboundSchema.parse(
+      riskYieldTransferRequestAmount,
+    ),
+  );
+}
+
+/** @internal */
+export const RiskYieldTransferRequestAction$outboundSchema: z.ZodNativeEnum<
+  typeof RiskYieldTransferRequestAction
+> = z.nativeEnum(RiskYieldTransferRequestAction);
+
+/** @internal */
+export type RiskYieldTransferRequest$Outbound = {
+  owner: string;
+  chain?: string | undefined;
+  token: string;
+  amount: number | string;
+  action: string;
+  gas_sponsorship?: boolean | undefined;
+  spender?: string | null | undefined;
+  recipient?: string | null | undefined;
+};
+
+/** @internal */
+export const RiskYieldTransferRequest$outboundSchema: z.ZodType<
+  RiskYieldTransferRequest$Outbound,
+  z.ZodTypeDef,
+  RiskYieldTransferRequest
+> = z.object({
+  owner: z.string(),
+  chain: RiskYieldTransferRequestChain$outboundSchema.optional(),
+  token: z.string(),
+  amount: z.union([z.number(), z.string()]),
+  action: RiskYieldTransferRequestAction$outboundSchema,
+  gasSponsorship: z.boolean().optional(),
+  spender: z.nullable(z.string()).optional(),
+  recipient: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    gasSponsorship: "gas_sponsorship",
+  });
+});
+
+export function riskYieldTransferRequestToJSON(
+  riskYieldTransferRequest: RiskYieldTransferRequest,
+): string {
+  return JSON.stringify(
+    RiskYieldTransferRequest$outboundSchema.parse(riskYieldTransferRequest),
+  );
+}

package/src/models/components/scenarioinput.ts

@@ -0,0 +1,125 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+/**
+ * How far the pair's ratio moves. This is what drives loss.
+ */
+export type RatioMovePct = number | string;
+
+/**
+ * How far token0 moves in dollars, independently. Mutually exclusive with `ratio_move_pct`.
+ */
+export type BaseUsdMovePct = number | string;
+
+/**
+ * How far token1 — the stock, on a meme x stock pair — moves in dollars. On its own this changes what the position is worth without causing any impermanent loss at all.
+ */
+export type QuoteUsdMovePct = number | string;
+
+/**
+ * One hypothetical.
+ *
+ * @remarks
+ *
+ * The two moves are deliberately separate. On a meme-against-stock pair the
+ * ratio between them is what causes impermanent loss, while the stock's own
+ * dollar move scales the whole position without touching the ratio — so "NVDA
+ * drops 10%" and "the memecoin drops 10% against NVDA" are different
+ * questions with different answers, and one number cannot ask both.
+ */
+export type ScenarioInput = {
+  /**
+   * What to call this row.
+   */
+  name?: string | null | undefined;
+  /**
+   * How far the pair's ratio moves. This is what drives loss.
+   */
+  ratioMovePct?: number | string | null | undefined;
+  /**
+   * How far token0 moves in dollars, independently. Mutually exclusive with `ratio_move_pct`.
+   */
+  baseUsdMovePct?: number | string | null | undefined;
+  /**
+   * How far token1 — the stock, on a meme x stock pair — moves in dollars. On its own this changes what the position is worth without causing any impermanent loss at all.
+   */
+  quoteUsdMovePct?: number | string | undefined;
+};
+
+/** @internal */
+export type RatioMovePct$Outbound = number | string;
+
+/** @internal */
+export const RatioMovePct$outboundSchema: z.ZodType<
+  RatioMovePct$Outbound,
+  z.ZodTypeDef,
+  RatioMovePct
+> = z.union([z.number(), z.string()]);
+
+export function ratioMovePctToJSON(ratioMovePct: RatioMovePct): string {
+  return JSON.stringify(RatioMovePct$outboundSchema.parse(ratioMovePct));
+}
+
+/** @internal */
+export type BaseUsdMovePct$Outbound = number | string;
+
+/** @internal */
+export const BaseUsdMovePct$outboundSchema: z.ZodType<
+  BaseUsdMovePct$Outbound,
+  z.ZodTypeDef,
+  BaseUsdMovePct
+> = z.union([z.number(), z.string()]);
+
+export function baseUsdMovePctToJSON(baseUsdMovePct: BaseUsdMovePct): string {
+  return JSON.stringify(BaseUsdMovePct$outboundSchema.parse(baseUsdMovePct));
+}
+
+/** @internal */
+export type QuoteUsdMovePct$Outbound = number | string;
+
+/** @internal */
+export const QuoteUsdMovePct$outboundSchema: z.ZodType<
+  QuoteUsdMovePct$Outbound,
+  z.ZodTypeDef,
+  QuoteUsdMovePct
+> = z.union([z.number(), z.string()]);
+
+export function quoteUsdMovePctToJSON(
+  quoteUsdMovePct: QuoteUsdMovePct,
+): string {
+  return JSON.stringify(QuoteUsdMovePct$outboundSchema.parse(quoteUsdMovePct));
+}
+
+/** @internal */
+export type ScenarioInput$Outbound = {
+  name?: string | null | undefined;
+  ratio_move_pct?: number | string | null | undefined;
+  base_usd_move_pct?: number | string | null | undefined;
+  quote_usd_move_pct?: number | string | undefined;
+};
+
+/** @internal */
+export const ScenarioInput$outboundSchema: z.ZodType<
+  ScenarioInput$Outbound,
+  z.ZodTypeDef,
+  ScenarioInput
+> = z.object({
+  name: z.nullable(z.string()).optional(),
+  ratioMovePct: z.nullable(z.union([z.number(), z.string()])).optional(),
+  baseUsdMovePct: z.nullable(z.union([z.number(), z.string()])).optional(),
+  quoteUsdMovePct: z.union([z.number(), z.string()]).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    ratioMovePct: "ratio_move_pct",
+    baseUsdMovePct: "base_usd_move_pct",
+    quoteUsdMovePct: "quote_usd_move_pct",
+  });
+});
+
+export function scenarioInputToJSON(scenarioInput: ScenarioInput): string {
+  return JSON.stringify(ScenarioInput$outboundSchema.parse(scenarioInput));
+}

package/src/models/components/scenarioresult.ts

@@ -0,0 +1,80 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ScenarioResult = {
+  name: string;
+  priceRatio: string;
+  endPrice: string;
+  inRangeAtEnd: boolean;
+  positionValueUsd: string;
+  holdValueUsd: string;
+  ilUsd: string;
+  ilPct: string;
+  holdPnlUsd: string;
+  expectedFeesUsd: string;
+  /**
+   * Hold profit, plus the impermanent loss, plus the fees.
+   */
+  netPnlUsd: string;
+  /**
+   * What this position would have to earn, annualized, for the loss to be worth taking. The number to compare against the pool's actual fee APR.
+   */
+  breakevenFeeAprPct?: string | null | undefined;
+  /**
+   * How long the pool's current fee rate would take to earn the loss back. Null when the pool pays liquidity providers nothing, which no amount of time fixes.
+   */
+  daysOfFeesToRecoverIl?: string | null | undefined;
+};
+
+/** @internal */
+export const ScenarioResult$inboundSchema: z.ZodType<
+  ScenarioResult,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  price_ratio: z.string(),
+  end_price: z.string(),
+  in_range_at_end: z.boolean(),
+  position_value_usd: z.string(),
+  hold_value_usd: z.string(),
+  il_usd: z.string(),
+  il_pct: z.string(),
+  hold_pnl_usd: z.string(),
+  expected_fees_usd: z.string(),
+  net_pnl_usd: z.string(),
+  breakeven_fee_apr_pct: z.nullable(z.string()).optional(),
+  days_of_fees_to_recover_il: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "price_ratio": "priceRatio",
+    "end_price": "endPrice",
+    "in_range_at_end": "inRangeAtEnd",
+    "position_value_usd": "positionValueUsd",
+    "hold_value_usd": "holdValueUsd",
+    "il_usd": "ilUsd",
+    "il_pct": "ilPct",
+    "hold_pnl_usd": "holdPnlUsd",
+    "expected_fees_usd": "expectedFeesUsd",
+    "net_pnl_usd": "netPnlUsd",
+    "breakeven_fee_apr_pct": "breakevenFeeAprPct",
+    "days_of_fees_to_recover_il": "daysOfFeesToRecoverIl",
+  });
+});
+
+export function scenarioResultFromJSON(
+  jsonString: string,
+): SafeParseResult<ScenarioResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ScenarioResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ScenarioResult' from JSON`,
+  );
+}

package/src/models/components/simulation.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * The result of executing the transaction against current state.
+ *
+ * @remarks
+ *
+ * Meme tokens on this chain carry transfer taxes, blacklists and pause
+ * switches, none of which are visible from a pool's parameters. Simulating is
+ * the only way to find out before the owner signs.
+ */
+export type Simulation = {
+  ok: boolean;
+  error?: string | null | undefined;
+  gasUsed?: number | null | undefined;
+};
+
+/** @internal */
+export const Simulation$inboundSchema: z.ZodType<
+  Simulation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ok: z.boolean(),
+  error: z.nullable(z.string()).optional(),
+  gas_used: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "gas_used": "gasUsed",
+  });
+});
+
+export function simulationFromJSON(
+  jsonString: string,
+): SafeParseResult<Simulation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Simulation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Simulation' from JSON`,
+  );
+}

package/src/models/components/singlesideddeposit.ts

@@ -0,0 +1,65 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type SingleSidedDepositAmount = number | string;
+
+/**
+ * One token, split to fit the range.
+ *
+ * @remarks
+ *
+ * A range needs both assets in a ratio the range itself determines, so this
+ * asks the API to solve for that ratio and swap the difference.
+ */
+export type SingleSidedDeposit = {
+  type: "single";
+  token: string;
+  amount: number | string;
+};
+
+/** @internal */
+export type SingleSidedDepositAmount$Outbound = number | string;
+
+/** @internal */
+export const SingleSidedDepositAmount$outboundSchema: z.ZodType<
+  SingleSidedDepositAmount$Outbound,
+  z.ZodTypeDef,
+  SingleSidedDepositAmount
+> = z.union([z.number(), z.string()]);
+
+export function singleSidedDepositAmountToJSON(
+  singleSidedDepositAmount: SingleSidedDepositAmount,
+): string {
+  return JSON.stringify(
+    SingleSidedDepositAmount$outboundSchema.parse(singleSidedDepositAmount),
+  );
+}
+
+/** @internal */
+export type SingleSidedDeposit$Outbound = {
+  type: "single";
+  token: string;
+  amount: number | string;
+};
+
+/** @internal */
+export const SingleSidedDeposit$outboundSchema: z.ZodType<
+  SingleSidedDeposit$Outbound,
+  z.ZodTypeDef,
+  SingleSidedDeposit
+> = z.object({
+  type: z.literal("single"),
+  token: z.string(),
+  amount: z.union([z.number(), z.string()]),
+});
+
+export function singleSidedDepositToJSON(
+  singleSidedDeposit: SingleSidedDeposit,
+): string {
+  return JSON.stringify(
+    SingleSidedDeposit$outboundSchema.parse(singleSidedDeposit),
+  );
+}