@compass-labs/api-sdk 0.0.23 → 0.0.25

package/src/models/components/aavehistoricaltransactionsresponse.ts

@@ -7,40 +7,265 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
-  AaveHistoricalTransactionBase,
-  AaveHistoricalTransactionBase$inboundSchema,
-  AaveHistoricalTransactionBase$Outbound,
-  AaveHistoricalTransactionBase$outboundSchema,
-} from "./aavehistoricaltransactionbase.js";
+  Borrow,
+  Borrow$inboundSchema,
+  Borrow$Outbound,
+  Borrow$outboundSchema,
+} from "./borrow.js";
+import {
+  LiquidationCall,
+  LiquidationCall$inboundSchema,
+  LiquidationCall$Outbound,
+  LiquidationCall$outboundSchema,
+} from "./liquidationcall.js";
+import {
+  RedeemUnderlying,
+  RedeemUnderlying$inboundSchema,
+  RedeemUnderlying$Outbound,
+  RedeemUnderlying$outboundSchema,
+} from "./redeemunderlying.js";
+import {
+  Repay,
+  Repay$inboundSchema,
+  Repay$Outbound,
+  Repay$outboundSchema,
+} from "./repay.js";
+import {
+  Supply,
+  Supply$inboundSchema,
+  Supply$Outbound,
+  Supply$outboundSchema,
+} from "./supply.js";
+import {
+  SwapBorrowRate,
+  SwapBorrowRate$inboundSchema,
+  SwapBorrowRate$Outbound,
+  SwapBorrowRate$outboundSchema,
+} from "./swapborrowrate.js";
+import {
+  UsageAsCollateral,
+  UsageAsCollateral$inboundSchema,
+  UsageAsCollateral$Outbound,
+  UsageAsCollateral$outboundSchema,
+} from "./usageascollateral.js";
+
+export type Transaction =
+  | (RedeemUnderlying & { action: "RedeemUnderlying" })
+  | (Repay & { action: "Repay" })
+  | (Supply & { action: "Supply" })
+  | (UsageAsCollateral & { action: "UsageAsCollateral" })
+  | (Borrow & { action: "Borrow" })
+  | (SwapBorrowRate & { action: "SwapBorrowRate" })
+  | (LiquidationCall & { action: "LiquidationCall" });
 
 /**
  * Response model for getting Aave historical transactions.
  */
 export type AaveHistoricalTransactionsResponse = {
-  total: number;
+  /**
+   * Specifies how many transactions to skip before returning results, letting you choose the starting point for the data you want to receive.
+   */
   offset: number;
+  /**
+   * Sets the maximum number of transactions to include in the response, helping control the size of the returned dataset.
+   */
   limit: number;
-  transactions: Array<AaveHistoricalTransactionBase>;
+  transactions: Array<
+    | (RedeemUnderlying & { action: "RedeemUnderlying" })
+    | (Repay & { action: "Repay" })
+    | (Supply & { action: "Supply" })
+    | (UsageAsCollateral & { action: "UsageAsCollateral" })
+    | (Borrow & { action: "Borrow" })
+    | (SwapBorrowRate & { action: "SwapBorrowRate" })
+    | (LiquidationCall & { action: "LiquidationCall" })
+  >;
 };
 
+/** @internal */
+export const Transaction$inboundSchema: z.ZodType<
+  Transaction,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  RedeemUnderlying$inboundSchema.and(
+    z.object({ action: z.literal("RedeemUnderlying") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  Repay$inboundSchema.and(
+    z.object({ action: z.literal("Repay") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  Supply$inboundSchema.and(
+    z.object({ action: z.literal("Supply") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  UsageAsCollateral$inboundSchema.and(
+    z.object({ action: z.literal("UsageAsCollateral") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  Borrow$inboundSchema.and(
+    z.object({ action: z.literal("Borrow") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  SwapBorrowRate$inboundSchema.and(
+    z.object({ action: z.literal("SwapBorrowRate") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  LiquidationCall$inboundSchema.and(
+    z.object({ action: z.literal("LiquidationCall") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+]);
+
+/** @internal */
+export type Transaction$Outbound =
+  | (RedeemUnderlying$Outbound & { action: "RedeemUnderlying" })
+  | (Repay$Outbound & { action: "Repay" })
+  | (Supply$Outbound & { action: "Supply" })
+  | (UsageAsCollateral$Outbound & { action: "UsageAsCollateral" })
+  | (Borrow$Outbound & { action: "Borrow" })
+  | (SwapBorrowRate$Outbound & { action: "SwapBorrowRate" })
+  | (LiquidationCall$Outbound & { action: "LiquidationCall" });
+
+/** @internal */
+export const Transaction$outboundSchema: z.ZodType<
+  Transaction$Outbound,
+  z.ZodTypeDef,
+  Transaction
+> = z.union([
+  RedeemUnderlying$outboundSchema.and(
+    z.object({ action: z.literal("RedeemUnderlying") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  Repay$outboundSchema.and(
+    z.object({ action: z.literal("Repay") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  Supply$outboundSchema.and(
+    z.object({ action: z.literal("Supply") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  UsageAsCollateral$outboundSchema.and(
+    z.object({ action: z.literal("UsageAsCollateral") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  Borrow$outboundSchema.and(
+    z.object({ action: z.literal("Borrow") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  SwapBorrowRate$outboundSchema.and(
+    z.object({ action: z.literal("SwapBorrowRate") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+  LiquidationCall$outboundSchema.and(
+    z.object({ action: z.literal("LiquidationCall") }).transform((v) => ({
+      action: v.action,
+    })),
+  ),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Transaction$ {
+  /** @deprecated use `Transaction$inboundSchema` instead. */
+  export const inboundSchema = Transaction$inboundSchema;
+  /** @deprecated use `Transaction$outboundSchema` instead. */
+  export const outboundSchema = Transaction$outboundSchema;
+  /** @deprecated use `Transaction$Outbound` instead. */
+  export type Outbound = Transaction$Outbound;
+}
+
+export function transactionToJSON(transaction: Transaction): string {
+  return JSON.stringify(Transaction$outboundSchema.parse(transaction));
+}
+
+export function transactionFromJSON(
+  jsonString: string,
+): SafeParseResult<Transaction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Transaction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Transaction' from JSON`,
+  );
+}
+
 /** @internal */
 export const AaveHistoricalTransactionsResponse$inboundSchema: z.ZodType<
   AaveHistoricalTransactionsResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  total: z.number().int(),
   offset: z.number().int(),
   limit: z.number().int(),
-  transactions: z.array(AaveHistoricalTransactionBase$inboundSchema),
+  transactions: z.array(
+    z.union([
+      RedeemUnderlying$inboundSchema.and(
+        z.object({ action: z.literal("RedeemUnderlying") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      Repay$inboundSchema.and(
+        z.object({ action: z.literal("Repay") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      Supply$inboundSchema.and(
+        z.object({ action: z.literal("Supply") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      UsageAsCollateral$inboundSchema.and(
+        z.object({ action: z.literal("UsageAsCollateral") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      Borrow$inboundSchema.and(
+        z.object({ action: z.literal("Borrow") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      SwapBorrowRate$inboundSchema.and(
+        z.object({ action: z.literal("SwapBorrowRate") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      LiquidationCall$inboundSchema.and(
+        z.object({ action: z.literal("LiquidationCall") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+    ]),
+  ),
 });
 
 /** @internal */
 export type AaveHistoricalTransactionsResponse$Outbound = {
-  total: number;
   offset: number;
   limit: number;
-  transactions: Array<AaveHistoricalTransactionBase$Outbound>;
+  transactions: Array<
+    | (RedeemUnderlying$Outbound & { action: "RedeemUnderlying" })
+    | (Repay$Outbound & { action: "Repay" })
+    | (Supply$Outbound & { action: "Supply" })
+    | (UsageAsCollateral$Outbound & { action: "UsageAsCollateral" })
+    | (Borrow$Outbound & { action: "Borrow" })
+    | (SwapBorrowRate$Outbound & { action: "SwapBorrowRate" })
+    | (LiquidationCall$Outbound & { action: "LiquidationCall" })
+  >;
 };
 
 /** @internal */
@@ -49,10 +274,47 @@ export const AaveHistoricalTransactionsResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AaveHistoricalTransactionsResponse
 > = z.object({
-  total: z.number().int(),
   offset: z.number().int(),
   limit: z.number().int(),
-  transactions: z.array(AaveHistoricalTransactionBase$outboundSchema),
+  transactions: z.array(
+    z.union([
+      RedeemUnderlying$outboundSchema.and(
+        z.object({ action: z.literal("RedeemUnderlying") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      Repay$outboundSchema.and(
+        z.object({ action: z.literal("Repay") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      Supply$outboundSchema.and(
+        z.object({ action: z.literal("Supply") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      UsageAsCollateral$outboundSchema.and(
+        z.object({ action: z.literal("UsageAsCollateral") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      Borrow$outboundSchema.and(
+        z.object({ action: z.literal("Borrow") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      SwapBorrowRate$outboundSchema.and(
+        z.object({ action: z.literal("SwapBorrowRate") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+      LiquidationCall$outboundSchema.and(
+        z.object({ action: z.literal("LiquidationCall") }).transform((v) => ({
+          action: v.action,
+        })),
+      ),
+    ]),
+  ),
 });
 
 /**

package/src/models/components/aavelooprequest.ts

@@ -0,0 +1,219 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+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";
+import { Chain, Chain$inboundSchema, Chain$outboundSchema } from "./chain.js";
+import {
+  SignedAuthorization,
+  SignedAuthorization$inboundSchema,
+  SignedAuthorization$Outbound,
+  SignedAuthorization$outboundSchema,
+} from "./signedauthorization.js";
+import {
+  TokenEnum,
+  TokenEnum$inboundSchema,
+  TokenEnum$outboundSchema,
+} from "./tokenenum.js";
+
+/**
+ * Amount of collateral token to supply to Aave
+ */
+export type CollateralAmount = number | string;
+
+/**
+ * Request model for executing an Aave loop transaction.
+ */
+export type AaveLoopRequest = {
+  /**
+   * The chain to use.
+   */
+  chain: Chain;
+  /**
+   * The address of the transaction sender.
+   */
+  sender: string;
+  signedAuthorization: SignedAuthorization;
+  /**
+   * A class representing the token.
+   *
+   * @remarks
+   *
+   * This class is used to represent the token in the system. Notice individual
+   * endpoints' documentation where per chain tokens are presented.
+   */
+  collateralToken: TokenEnum;
+  /**
+   * A class representing the token.
+   *
+   * @remarks
+   *
+   * This class is used to represent the token in the system. Notice individual
+   * endpoints' documentation where per chain tokens are presented.
+   */
+  borrowToken: TokenEnum;
+  /**
+   * Amount of collateral token to supply to Aave
+   */
+  collateralAmount: number | string;
+  /**
+   * Number of times to perform the supply-borrow loop
+   */
+  loopCount: number;
+  /**
+   * Maximum allowed slippage for token swaps in percentage
+   */
+  maxSlippagePercent: number;
+  /**
+   * Loan To Value percentage of the loop
+   */
+  loanToValue: number;
+};
+
+/** @internal */
+export const CollateralAmount$inboundSchema: z.ZodType<
+  CollateralAmount,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.number(), z.string()]);
+
+/** @internal */
+export type CollateralAmount$Outbound = number | string;
+
+/** @internal */
+export const CollateralAmount$outboundSchema: z.ZodType<
+  CollateralAmount$Outbound,
+  z.ZodTypeDef,
+  CollateralAmount
+> = z.union([z.number(), z.string()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace CollateralAmount$ {
+  /** @deprecated use `CollateralAmount$inboundSchema` instead. */
+  export const inboundSchema = CollateralAmount$inboundSchema;
+  /** @deprecated use `CollateralAmount$outboundSchema` instead. */
+  export const outboundSchema = CollateralAmount$outboundSchema;
+  /** @deprecated use `CollateralAmount$Outbound` instead. */
+  export type Outbound = CollateralAmount$Outbound;
+}
+
+export function collateralAmountToJSON(
+  collateralAmount: CollateralAmount,
+): string {
+  return JSON.stringify(
+    CollateralAmount$outboundSchema.parse(collateralAmount),
+  );
+}
+
+export function collateralAmountFromJSON(
+  jsonString: string,
+): SafeParseResult<CollateralAmount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollateralAmount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollateralAmount' from JSON`,
+  );
+}
+
+/** @internal */
+export const AaveLoopRequest$inboundSchema: z.ZodType<
+  AaveLoopRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  chain: Chain$inboundSchema,
+  sender: z.string(),
+  signed_authorization: SignedAuthorization$inboundSchema,
+  collateral_token: TokenEnum$inboundSchema,
+  borrow_token: TokenEnum$inboundSchema,
+  collateral_amount: z.union([z.number(), z.string()]),
+  loop_count: z.number().int(),
+  max_slippage_percent: z.number(),
+  loan_to_value: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "signed_authorization": "signedAuthorization",
+    "collateral_token": "collateralToken",
+    "borrow_token": "borrowToken",
+    "collateral_amount": "collateralAmount",
+    "loop_count": "loopCount",
+    "max_slippage_percent": "maxSlippagePercent",
+    "loan_to_value": "loanToValue",
+  });
+});
+
+/** @internal */
+export type AaveLoopRequest$Outbound = {
+  chain: string;
+  sender: string;
+  signed_authorization: SignedAuthorization$Outbound;
+  collateral_token: string;
+  borrow_token: string;
+  collateral_amount: number | string;
+  loop_count: number;
+  max_slippage_percent: number;
+  loan_to_value: number;
+};
+
+/** @internal */
+export const AaveLoopRequest$outboundSchema: z.ZodType<
+  AaveLoopRequest$Outbound,
+  z.ZodTypeDef,
+  AaveLoopRequest
+> = z.object({
+  chain: Chain$outboundSchema,
+  sender: z.string(),
+  signedAuthorization: SignedAuthorization$outboundSchema,
+  collateralToken: TokenEnum$outboundSchema,
+  borrowToken: TokenEnum$outboundSchema,
+  collateralAmount: z.union([z.number(), z.string()]),
+  loopCount: z.number().int(),
+  maxSlippagePercent: z.number(),
+  loanToValue: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    signedAuthorization: "signed_authorization",
+    collateralToken: "collateral_token",
+    borrowToken: "borrow_token",
+    collateralAmount: "collateral_amount",
+    loopCount: "loop_count",
+    maxSlippagePercent: "max_slippage_percent",
+    loanToValue: "loan_to_value",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AaveLoopRequest$ {
+  /** @deprecated use `AaveLoopRequest$inboundSchema` instead. */
+  export const inboundSchema = AaveLoopRequest$inboundSchema;
+  /** @deprecated use `AaveLoopRequest$outboundSchema` instead. */
+  export const outboundSchema = AaveLoopRequest$outboundSchema;
+  /** @deprecated use `AaveLoopRequest$Outbound` instead. */
+  export type Outbound = AaveLoopRequest$Outbound;
+}
+
+export function aaveLoopRequestToJSON(
+  aaveLoopRequest: AaveLoopRequest,
+): string {
+  return JSON.stringify(AaveLoopRequest$outboundSchema.parse(aaveLoopRequest));
+}
+
+export function aaveLoopRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<AaveLoopRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AaveLoopRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AaveLoopRequest' from JSON`,
+  );
+}

package/src/models/components/borrow.ts

@@ -4,6 +4,7 @@
 
 import * as z from "zod";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -13,37 +14,97 @@ import {
   Reserve$outboundSchema,
 } from "./reserve.js";
 
+/**
+ * The interest rate mode to borrow: 1 represents stable interest rate mode. 2 represents variable interest rate mode
+ */
+export const Borrowratemode = {
+  One: 1,
+  Two: 2,
+} as const;
+/**
+ * The interest rate mode to borrow: 1 represents stable interest rate mode. 2 represents variable interest rate mode
+ */
+export type Borrowratemode = ClosedEnum<typeof Borrowratemode>;
+
 export type Borrow = {
-  amount: string;
-  borrowRateMode: string;
-  borrowRate: string;
-  stableTokenDebt: string;
-  variableTokenDebt: string;
+  /**
+   * The id of a historical transaction on aave
+   */
+  id: string;
+  /**
+   * Timestamp in unix time
+   */
+  timestamp: number;
+  /**
+   * Transaction hash. You can paste these into the search bar on etherscan
+   */
+  txHash: string;
+  /**
+   * Quantity of token
+   */
+  amount: number;
+  /**
+   * The interest rate mode to borrow: 1 represents stable interest rate mode. 2 represents variable interest rate mode
+   */
+  borrowRateMode: Borrowratemode;
   reserve: Reserve;
-  assetPriceUSD: string;
+  /**
+   * Price of token in USD
+   */
+  assetPriceUSD: number;
+  /**
+   * The type of transaction
+   */
+  action?: "Borrow" | undefined;
+  block: number;
 };
 
+/** @internal */
+export const Borrowratemode$inboundSchema: z.ZodNativeEnum<
+  typeof Borrowratemode
+> = z.nativeEnum(Borrowratemode);
+
+/** @internal */
+export const Borrowratemode$outboundSchema: z.ZodNativeEnum<
+  typeof Borrowratemode
+> = Borrowratemode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Borrowratemode$ {
+  /** @deprecated use `Borrowratemode$inboundSchema` instead. */
+  export const inboundSchema = Borrowratemode$inboundSchema;
+  /** @deprecated use `Borrowratemode$outboundSchema` instead. */
+  export const outboundSchema = Borrowratemode$outboundSchema;
+}
+
 /** @internal */
 export const Borrow$inboundSchema: z.ZodType<Borrow, z.ZodTypeDef, unknown> = z
   .object({
-    amount: z.string(),
-    borrowRateMode: z.string(),
-    borrowRate: z.string(),
-    stableTokenDebt: z.string(),
-    variableTokenDebt: z.string(),
+    id: z.string(),
+    timestamp: z.number().int(),
+    txHash: z.string(),
+    amount: z.number(),
+    borrowRateMode: Borrowratemode$inboundSchema,
     reserve: Reserve$inboundSchema,
-    assetPriceUSD: z.string(),
+    assetPriceUSD: z.number(),
+    action: z.literal("Borrow").optional(),
+    block: z.number().int(),
   });
 
 /** @internal */
 export type Borrow$Outbound = {
-  amount: string;
-  borrowRateMode: string;
-  borrowRate: string;
-  stableTokenDebt: string;
-  variableTokenDebt: string;
+  id: string;
+  timestamp: number;
+  txHash: string;
+  amount: number;
+  borrowRateMode: number;
   reserve: Reserve$Outbound;
-  assetPriceUSD: string;
+  assetPriceUSD: number;
+  action: "Borrow";
+  block: number;
 };
 
 /** @internal */
@@ -52,13 +113,15 @@ export const Borrow$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Borrow
 > = z.object({
-  amount: z.string(),
-  borrowRateMode: z.string(),
-  borrowRate: z.string(),
-  stableTokenDebt: z.string(),
-  variableTokenDebt: z.string(),
+  id: z.string(),
+  timestamp: z.number().int(),
+  txHash: z.string(),
+  amount: z.number(),
+  borrowRateMode: Borrowratemode$outboundSchema,
   reserve: Reserve$outboundSchema,
-  assetPriceUSD: z.string(),
+  assetPriceUSD: z.number(),
+  action: z.literal("Borrow").default("Borrow" as const),
+  block: z.number().int(),
 });
 
 /**