@compass-labs/api-sdk 0.5.13 → 0.5.14

package/src/models/components/multicallexecuterequest.ts

@@ -0,0 +1,112 @@
+/*
+ * 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 {
+  UserOperation,
+  UserOperation$inboundSchema,
+  UserOperation$Outbound,
+  UserOperation$outboundSchema,
+} from "./useroperation.js";
+
+/**
+ * Request model for executing a multicall.
+ */
+export type MulticallExecuteRequest = {
+  /**
+   * The chain to use.
+   */
+  chain: Chain;
+  /**
+   * The address of the transaction sender.
+   */
+  sender: string;
+  signedAuthorization: SignedAuthorization;
+  /**
+   * List of possible actions for multicall
+   */
+  actions: Array<UserOperation>;
+};
+
+/** @internal */
+export const MulticallExecuteRequest$inboundSchema: z.ZodType<
+  MulticallExecuteRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  chain: Chain$inboundSchema,
+  sender: z.string(),
+  signed_authorization: SignedAuthorization$inboundSchema,
+  actions: z.array(UserOperation$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "signed_authorization": "signedAuthorization",
+  });
+});
+
+/** @internal */
+export type MulticallExecuteRequest$Outbound = {
+  chain: string;
+  sender: string;
+  signed_authorization: SignedAuthorization$Outbound;
+  actions: Array<UserOperation$Outbound>;
+};
+
+/** @internal */
+export const MulticallExecuteRequest$outboundSchema: z.ZodType<
+  MulticallExecuteRequest$Outbound,
+  z.ZodTypeDef,
+  MulticallExecuteRequest
+> = z.object({
+  chain: Chain$outboundSchema,
+  sender: z.string(),
+  signedAuthorization: SignedAuthorization$outboundSchema,
+  actions: z.array(UserOperation$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    signedAuthorization: "signed_authorization",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace MulticallExecuteRequest$ {
+  /** @deprecated use `MulticallExecuteRequest$inboundSchema` instead. */
+  export const inboundSchema = MulticallExecuteRequest$inboundSchema;
+  /** @deprecated use `MulticallExecuteRequest$outboundSchema` instead. */
+  export const outboundSchema = MulticallExecuteRequest$outboundSchema;
+  /** @deprecated use `MulticallExecuteRequest$Outbound` instead. */
+  export type Outbound = MulticallExecuteRequest$Outbound;
+}
+
+export function multicallExecuteRequestToJSON(
+  multicallExecuteRequest: MulticallExecuteRequest,
+): string {
+  return JSON.stringify(
+    MulticallExecuteRequest$outboundSchema.parse(multicallExecuteRequest),
+  );
+}
+
+export function multicallExecuteRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<MulticallExecuteRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MulticallExecuteRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MulticallExecuteRequest' from JSON`,
+  );
+}

package/src/sdk/sdk.ts

@@ -10,6 +10,7 @@ import { Pendle } from "./pendle.js";
 import { Sky } from "./sky.js";
 import { SmartAccount } from "./smartaccount.js";
 import { Token } from "./token.js";
+import { TransactionBatching } from "./transactionbatching.js";
 import { UniswapV3 } from "./uniswapv3.js";
 import { Universal } from "./universal.js";
 
@@ -56,6 +57,13 @@ export class CompassApiSDK extends ClientSDK {
     return (this._pendle ??= new Pendle(this._options));
   }
 
+  private _transactionBatching?: TransactionBatching;
+  get transactionBatching(): TransactionBatching {
+    return (this._transactionBatching ??= new TransactionBatching(
+      this._options,
+    ));
+  }
+
   private _smartAccount?: SmartAccount;
   get smartAccount(): SmartAccount {
     return (this._smartAccount ??= new SmartAccount(this._options));

package/src/sdk/transactionbatching.ts

@@ -0,0 +1,84 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { transactionBatchingAaveLoop } from "../funcs/transactionBatchingAaveLoop.js";
+import { transactionBatchingAuthorization } from "../funcs/transactionBatchingAuthorization.js";
+import { transactionBatchingExecute } from "../funcs/transactionBatchingExecute.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class TransactionBatching extends ClientSDK {
+  /**
+   * Enable transaction bundling.
+   *
+   * @remarks
+   * Get authorization for bundling transactions.
+   *
+   * Currently this is required for every transaction bundle to prevent replay attacks
+   * and ensure transaction ordering when batching multiple actions into a single
+   * transaction. The authorization includes a nonce and chain ID to guarantee
+   * transaction uniqueness and proper network targeting.
+   */
+  async authorization(
+    request: components.MulticallAuthorizationRequest,
+    options?: RequestOptions,
+  ): Promise<components.MulticallAuthorizationResponse> {
+    return unwrapAsync(transactionBatchingAuthorization(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Construct Bundled Transaction
+   *
+   * @remarks
+   * Bundle arbitrary transactions together into a single multicall transaction using
+   * EIP-7702.
+   *
+   * This endpoint allows bundling multiple contract calls into a single atomic
+   * transaction, reducing gas costs and ensuring all operations succeed or fail
+   * together. The transaction must be authorized using the /authorization endpoint to
+   * prevent replay attacks.
+   */
+  async execute(
+    request: components.MulticallExecuteRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedMulticallTransaction> {
+    return unwrapAsync(transactionBatchingExecute(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * AAVE leverage long/short
+   *
+   * @remarks
+   * Execute an Aave looping strategy that involves repeated supply and borrow
+   * operations.
+   *
+   * This endpoint creates a multicall transaction that performs a series of operations:
+   * 1. Approves and supplies initial token
+   * 2. For each loop:
+   *     - Borrows another token
+   *     - Swaps borrowed token back to supply token
+   *     - Supplies the swapped tokens
+   *
+   * The transaction must be authorized using the /authorization endpoint to prevent replay attacks.
+   */
+  async aaveLoop(
+    request: components.AaveLoopRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedMulticallTransaction> {
+    return unwrapAsync(transactionBatchingAaveLoop(
+      this,
+      request,
+      options,
+    ));
+  }
+}