@otim/utils 0.0.4 → 0.0.6

package/dist/api/index.js

@@ -1,2095 +1,1615 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const require_chunk = require('../chunk-kSYXY2_d.js');
+const require_api_urls = require('../api-urls-Cd20DG4i.js');
+const require_defineProperty = require('../defineProperty-DbMdhrDE.js');
+let zod = require("zod");
+let axios = require("axios");
+axios = require_chunk.__toESM(axios);
+let _otim_utils_schemas = require("@otim/utils/schemas");
+let _otim_utils_helpers = require("@otim/utils/helpers");
 
-// src/api/index.ts
-var api_exports = {};
-__export(api_exports, {
-  APIClient: () => APIClient,
-  AccountService: () => AccountService,
-  ActivityService: () => ActivityService,
-  AuthService: () => AuthService,
-  ConfigService: () => ConfigService,
-  ContactsService: () => ContactsService,
-  DelegationStatus: () => DelegationStatus,
-  DeveloperService: () => DeveloperService,
-  HttpMethod: () => HttpMethod,
-  InstructionService: () => InstructionService,
-  IntegrationService: () => IntegrationService,
-  IntegrationType: () => IntegrationType,
-  OperatingAccountService: () => OperatingAccountService,
-  PaymentsService: () => PaymentsService,
-  ServiceError: () => ServiceError,
-  TransactionService: () => TransactionService,
-  UniswapTokenListService: () => UniswapTokenListService,
-  actionArgumentsResponseSchema: () => actionArgumentsResponseSchema,
-  actionArgumentsSchema: () => actionArgumentsSchema,
-  actionNameSchema: () => actionNameSchema,
-  activityDataSchema: () => activityDataSchema,
-  activityRecordSchema: () => activityRecordSchema,
-  addressWhitelistCheckRequestSchema: () => addressWhitelistCheckRequestSchema,
-  addressWhitelistCheckResponseSchema: () => addressWhitelistCheckResponseSchema,
-  apiErrorSchema: () => apiErrorSchema,
-  attestationSchema: () => attestationSchema,
-  authLoginRequestSchema: () => authLoginRequestSchema,
-  authLoginResponseSchema: () => authLoginResponseSchema,
-  buildEphemeralInstructionSchema: () => buildEphemeralInstructionSchema,
-  buildSettlementRequestSchema: () => buildSettlementRequestSchema,
-  buildSettlementResponseSchema: () => buildSettlementResponseSchema,
-  calculateHasMore: () => calculateHasMore,
-  chainIdSchema: () => chainIdSchema,
-  chainSuccessResponseSchema: () => chainSuccessResponseSchema,
-  contactSchema: () => contactSchema,
-  createAPIClient: () => createAPIClient,
-  createAbortController: () => createAbortController,
-  createInstance: () => createInstance,
-  delegationCreateRequestSchema: () => delegationCreateRequestSchema,
-  delegationCreateResponseSchema: () => delegationCreateResponseSchema,
-  delegationStatusRequestSchema: () => delegationStatusRequestSchema,
-  delegationStatusResponseSchema: () => delegationStatusResponseSchema,
-  delegationStatusSchema: () => delegationStatusSchema,
-  delegationStatusValues: () => delegationStatusValues,
-  errorResponseSchema: () => errorResponseSchema,
-  extractPaginationParams: () => extractPaginationParams,
-  feeResponseSchema: () => feeResponseSchema2,
-  getConfigChainsResponseSchema: () => getConfigChainsResponseSchema,
-  getConfigTokensRequestParametersSchema: () => getConfigTokensRequestParametersSchema,
-  getConfigTokensResponseSchema: () => getConfigTokensResponseSchema,
-  getContactsRequestSchema: () => getContactsRequestSchema,
-  getContactsResponseSchema: () => getContactsResponseSchema,
-  getCurrentUserResponseSchema: () => getCurrentUserResponseSchema,
-  getDefaultPagination: () => getDefaultPagination,
-  getDelegateAddressResponseSchema: () => getDelegateAddressResponseSchema,
-  getDelegateAddressSchema: () => getDelegateAddressSchema,
-  getErrorMessage: () => getErrorMessage,
-  getErrorMessageWithCode: () => getErrorMessageWithCode,
-  getInstructionActivityRequestSchema: () => getInstructionActivityRequestSchema,
-  getInstructionActivityResponseSchema: () => getInstructionActivityResponseSchema,
-  getIntegrationRequestSchema: () => getIntegrationRequestSchema,
-  getMaxPriorityFeePerGasEstimateResponseSchema: () => getMaxPriorityFeePerGasEstimateResponseSchema,
-  getMaxPriorityFeePerGasEstimateSchema: () => getMaxPriorityFeePerGasEstimateSchema,
-  getOperatingAccountSubOrgResponseSchema: () => getOperatingAccountSubOrgResponseSchema,
-  getPaymentRequestsRequestSchema: () => getPaymentRequestsRequestSchema,
-  getPaymentRequestsResponseSchema: () => getPaymentRequestsResponseSchema,
-  getUserFriendlyErrorMessage: () => getUserFriendlyErrorMessage,
-  instructionActivateRequestSchema: () => instructionActivateRequestSchema,
-  instructionActivateResponseSchema: () => instructionActivateResponseSchema,
-  instructionBuildRequestSchema: () => instructionBuildRequestSchema,
-  instructionBuildSchema: () => instructionBuildSchema,
-  instructionDeactivateRequestSchema: () => instructionDeactivateRequestSchema,
-  instructionDeactivateResponseSchema: () => instructionDeactivateResponseSchema,
-  instructionDetailsRequestSchema: () => instructionDetailsRequestSchema,
-  instructionDetailsResponseSchema: () => instructionDetailsResponseSchema,
-  instructionGetAllRequestSchema: () => instructionGetAllRequestSchema,
-  instructionGetAllResponseSchema: () => instructionGetAllResponseSchema,
-  instructionGetRulesRequestSchema: () => instructionGetRulesRequestSchema,
-  instructionGetRulesResponseSchema: () => instructionGetRulesResponseSchema,
-  integrationResponseSchema: () => integrationResponseSchema,
-  integrationTypeSchema: () => integrationTypeSchema,
-  integrationTypeValues: () => integrationTypeValues,
-  isInstanceInit: () => isInstanceInit,
-  isTechnicalError: () => isTechnicalError,
-  isUserAddressableError: () => isUserAddressableError,
-  isUserRejectionError: () => isUserRejectionError,
-  meResponseSchema: () => meResponseSchema,
-  newContactRequestSchema: () => newContactRequestSchema,
-  newInstructionRequestSchema: () => newInstructionRequestSchema,
-  newOperatingAccountSubOrgResponseSchema: () => newOperatingAccountSubOrgResponseSchema,
-  paymentRequestBuildRequestSchema: () => paymentRequestBuildRequestSchema,
-  paymentRequestBuildResponseSchema: () => paymentRequestBuildResponseSchema,
-  paymentRequestDetailsRequestSchema: () => paymentRequestDetailsRequestSchema,
-  paymentRequestDetailsResponseSchema: () => paymentRequestDetailsResponseSchema,
-  paymentRequestNewRequestSchema: () => paymentRequestNewRequestSchema,
-  paymentRequestSchema: () => paymentRequestSchema,
-  paymentRequestStatusSchema: () => paymentRequestStatusSchema,
-  paymentRequestsDirectionSchema: () => paymentRequestsDirectionSchema,
-  sessionTokenRequestSchema: () => sessionTokenRequestSchema,
-  sessionTokenResponseSchema: () => sessionTokenResponseSchema,
-  sessionVerifyResponseSchema: () => sessionVerifyResponseSchema,
-  setChainIdSchema: () => setChainIdSchema,
-  transactionGetListRequestSchema: () => transactionGetListRequestSchema,
-  transactionGetListResponseSchema: () => transactionGetListResponseSchema,
-  turnkeyLoginRequestSchema: () => turnkeyLoginRequestSchema,
-  turnkeyLoginResponseSchema: () => turnkeyLoginResponseSchema,
-  turnkeyVerificationRequestSchema: () => turnkeyVerificationRequestSchema,
-  turnkeyVerificationResponseSchema: () => turnkeyVerificationResponseSchema,
-  updateIntegrationRequestSchema: () => updateIntegrationRequestSchema,
-  whitelistCheckRequestSchema: () => whitelistCheckRequestSchema,
-  whitelistCheckResponseSchema: () => whitelistCheckResponseSchema
-});
-module.exports = __toCommonJS(api_exports);
-
-// src/api/core/error.ts
-var import_zod = require("zod");
-var apiErrorSchema = import_zod.z.object({
-  code: import_zod.z.string().nullish(),
-  message: import_zod.z.string().nullish(),
-  errorCode: import_zod.z.string().nullish(),
-  errorMessage: import_zod.z.string().nullish(),
-  status: import_zod.z.number().nullish(),
-  context: import_zod.z.object({
-    field_errors: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).nullish()
-  }).nullish()
-});
-var errorResponseSchema = import_zod.z.object({
-  message: import_zod.z.string().nullish(),
-  errorMessage: import_zod.z.string().nullish(),
-  errorCode: import_zod.z.string().nullish(),
-  errors: import_zod.z.array(apiErrorSchema).nullish()
-});
-var defaultErrorCode = "unknown";
-var defaultErrorMessage = "Unexpected error";
+//#region src/api/core/error.ts
+const apiErrorSchema = zod.z.object({
+	code: zod.z.string().nullish(),
+	message: zod.z.string().nullish(),
+	errorCode: zod.z.string().nullish(),
+	errorMessage: zod.z.string().nullish(),
+	status: zod.z.number().nullish(),
+	context: zod.z.object({ field_errors: zod.z.record(zod.z.string(), zod.z.string()).nullish() }).nullish()
+});
+const errorResponseSchema = zod.z.object({
+	message: zod.z.string().nullish(),
+	errorMessage: zod.z.string().nullish(),
+	errorCode: zod.z.string().nullish(),
+	errors: zod.z.array(apiErrorSchema).nullish()
+});
+const defaultErrorCode = "unknown";
+const defaultErrorMessage = "Unexpected error";
+/**
+* Extract the most likely server-provided error payload from a thrown value.
+* Supports common shapes from HTTP clients (Axios/fetch) and plain objects.
+*/
 function extractErrorData(maybeError) {
-  let errorData = maybeError?.body;
-  if (!errorData && maybeError?.response?.data) {
-    errorData = maybeError.response.data;
-  }
-  if (!errorData && (maybeError?.errorMessage || maybeError?.message || maybeError?.errorCode)) {
-    errorData = maybeError;
-  }
-  return errorData;
+	let errorData = maybeError?.body;
+	if (!errorData && maybeError?.response?.data) errorData = maybeError.response.data;
+	if (!errorData && (maybeError?.errorMessage || maybeError?.message || maybeError?.errorCode)) errorData = maybeError;
+	return errorData;
 }
+/**
+* Normalize Error Shapes Into One User‑Facing Message.
+* Why: Prefer server messages and avoid leaking technical details.
+*
+* @param maybeError An unknown error thrown by an HTTP client, SDK, or server.
+* @param fallbackMessage Message used when the payload cannot be parsed or
+* lacks a message.
+*/
 function getErrorMessage(maybeError, fallbackMessage) {
-  const errorMessage = fallbackMessage ?? defaultErrorMessage;
-  const errorData = extractErrorData(maybeError);
-  const result = errorResponseSchema.safeParse(errorData);
-  if (!result.success) {
-    return errorMessage;
-  }
-  const { message, errorMessage: apiErrorMessage, errors } = result.data;
-  return apiErrorMessage ?? message ?? errors?.[0]?.errorMessage ?? errors?.[0]?.message ?? errorMessage;
+	const errorMessage = fallbackMessage ?? defaultErrorMessage;
+	const errorData = extractErrorData(maybeError);
+	const result = errorResponseSchema.safeParse(errorData);
+	if (!result.success) return errorMessage;
+	const { message, errorMessage: apiErrorMessage, errors } = result.data;
+	/**
+	* Prioritize Error Message From Backend, Then Message, Then Errors Array.
+	* Surfaces the most specific, server‑intended feedback first for better UX.
+	*/
+	return apiErrorMessage ?? message ?? errors?.[0]?.errorMessage ?? errors?.[0]?.message ?? errorMessage;
 }
+/**
+* Provide A Unified Error Message And Code For UI/Control‑Flow.
+* Why: Normalize shapes and fall back to an "unknown" code.
+*
+* @param maybeError An unknown error thrown by an HTTP client, SDK, or server.
+* @param fallbackMessage Message used when the payload cannot be parsed or is
+* empty.
+*/
 function getErrorMessageWithCode(maybeError, fallbackMessage) {
-  const errorMessage = fallbackMessage ?? defaultErrorMessage;
-  const errorData = extractErrorData(maybeError);
-  const result = errorResponseSchema.safeParse(errorData);
-  if (!result.success || !result.data.errors?.[0] && !result.data.errorMessage && !result.data.message) {
-    return {
-      message: errorMessage,
-      code: defaultErrorCode
-    };
-  }
-  const {
-    message,
-    errorMessage: apiErrorMessage,
-    errorCode,
-    errors
-  } = result.data;
-  return {
-    message: apiErrorMessage ?? message ?? errors?.[0]?.errorMessage ?? errors?.[0]?.message ?? errorMessage,
-    code: errorCode ?? errors?.[0]?.errorCode ?? errors?.[0]?.code ?? defaultErrorCode
-  };
+	const errorMessage = fallbackMessage ?? defaultErrorMessage;
+	const errorData = extractErrorData(maybeError);
+	const result = errorResponseSchema.safeParse(errorData);
+	if (!result.success || !result.data.errors?.[0] && !result.data.errorMessage && !result.data.message) return {
+		message: errorMessage,
+		code: defaultErrorCode
+	};
+	const { message, errorMessage: apiErrorMessage, errorCode, errors } = result.data;
+	return {
+		message: apiErrorMessage ?? message ?? errors?.[0]?.errorMessage ?? errors?.[0]?.message ?? errorMessage,
+		code: errorCode ?? errors?.[0]?.errorCode ?? errors?.[0]?.code ?? defaultErrorCode
+	};
 }
+/**
+* Detect User Rejection (e.g., Canceled Wallet Signature).
+* Why: Treat cancellations as benign and keep telemetry clean.
+*
+* @param error The error object to check.
+* @returns true if the error is a user rejection, false otherwise.
+*/
 function isUserRejectionError(error) {
-  if (!error) return false;
-  let errorMessage = "";
-  if (typeof error === "string") {
-    errorMessage = error;
-  } else if (typeof error === "object") {
-    errorMessage = error.message || error.errorMessage || error.details || "";
-  }
-  if (!errorMessage) {
-    errorMessage = String(error);
-  }
-  errorMessage = errorMessage.toLowerCase();
-  const rejectionPatterns = [
-    "user rejected",
-    "user denied",
-    "user cancelled",
-    "cancelled by user",
-    "rejected by user",
-    "user abort",
-    "transaction rejected",
-    "signature rejected",
-    "request rejected"
-  ];
-  return rejectionPatterns.some((pattern) => errorMessage.includes(pattern));
+	if (!error) return false;
+	/**
+	* Safely Extract Error Message From Various Possible Error Formats.
+	* Providers may throw strings, plain objects, or non-Error values.
+	*/
+	let errorMessage = "";
+	if (typeof error === "string") errorMessage = error;
+	else if (typeof error === "object") errorMessage = error.message || error.errorMessage || error.details || "";
+	if (!errorMessage) errorMessage = String(error);
+	errorMessage = errorMessage.toLowerCase();
+	return [
+		"user rejected",
+		"user denied",
+		"user cancelled",
+		"cancelled by user",
+		"rejected by user",
+		"user abort",
+		"transaction rejected",
+		"signature rejected",
+		"request rejected"
+	].some((pattern) => errorMessage.includes(pattern));
 }
-var isUserAddressableError = (errorCode, errorMessage) => {
-  const isInUserErrorRange = errorCode >= 1e3 && errorCode < 2e3;
-  const hasErrorMessage = Boolean(errorMessage);
-  return isInUserErrorRange && hasErrorMessage;
+/**
+* Determine If An Error Code Is User‑Addressable.
+* Why: 1000–1999 are intended to be surfaced to users.
+*
+* @param errorCode The error code to check.
+* @param errorMessage Optional error message.
+*/
+const isUserAddressableError = (errorCode, errorMessage) => {
+	return errorCode >= 1e3 && errorCode < 2e3 && Boolean(errorMessage);
 };
+/**
+* Detect Whether An Error Looks Technical/Low‑Level.
+* Why: Avoid leaking framework/runtime details to users; rely on logging.
+*/
 function isTechnicalError(error) {
-  if (!error) return false;
-  let errorMessage = "";
-  if (typeof error === "string") {
-    errorMessage = error;
-  } else if (typeof error === "object") {
-    errorMessage = error.message || error.errorMessage || error.details || "";
-  }
-  if (!errorMessage) {
-    errorMessage = String(error);
-  }
-  errorMessage = errorMessage.toLowerCase();
-  const technicalErrorPatterns = [
-    "is not a function",
-    "cannot read prop",
-    "cannot read property",
-    "reading undefined",
-    "read undefined of",
-    "cannot access before initialization",
-    "is not defined",
-    "is undefined",
-    "is null",
-    "unexpected token",
-    "syntax error",
-    "reference error",
-    "type error",
-    "network error",
-    "failed to fetch",
-    "server components"
-  ];
-  return technicalErrorPatterns.some(
-    (pattern) => errorMessage.includes(pattern)
-  );
+	if (!error) return false;
+	/**
+	* Safely Extract Error Message From Various Possible Error Formats.
+	* Upstream code can throw strings or custom objects instead of Error
+	* instances.
+	*/
+	let errorMessage = "";
+	if (typeof error === "string") errorMessage = error;
+	else if (typeof error === "object") errorMessage = error.message || error.errorMessage || error.details || "";
+	if (!errorMessage) errorMessage = String(error);
+	errorMessage = errorMessage.toLowerCase();
+	return [
+		"is not a function",
+		"cannot read prop",
+		"cannot read property",
+		"reading undefined",
+		"read undefined of",
+		"cannot access before initialization",
+		"is not defined",
+		"is undefined",
+		"is null",
+		"unexpected token",
+		"syntax error",
+		"reference error",
+		"type error",
+		"network error",
+		"failed to fetch",
+		"server components"
+	].some((pattern) => errorMessage.includes(pattern));
 }
 function getUserFriendlyErrorMessage(error, fallbackMessage) {
-  if (isTechnicalError(error)) {
-    return "Internal server error";
-  }
-  return getErrorMessage(error, fallbackMessage);
+	if (isTechnicalError(error)) return "Internal server error";
+	return getErrorMessage(error, fallbackMessage);
 }
 
-// src/api/core/instance.ts
-var import_axios = __toESM(require("axios"));
-var API_INSTANCE_DEFAULT_TIMEOUT = 3e4;
-var createInstance = (config) => {
-  const instance = import_axios.default.create({
-    timeout: API_INSTANCE_DEFAULT_TIMEOUT,
-    ...config
-  });
-  return instance;
+//#endregion
+//#region src/api/core/instance.ts
+const API_INSTANCE_DEFAULT_TIMEOUT = 3e4;
+const createInstance = (config) => {
+	return axios.default.create({
+		timeout: API_INSTANCE_DEFAULT_TIMEOUT,
+		...config
+	});
 };
-var createAbortController = () => {
-  return new AbortController();
+const createAbortController = () => {
+	return new AbortController();
 };
-var isInstanceInit = (init) => {
-  return !!init && typeof init === "object" && "instance" in init;
+const isInstanceInit = (init) => {
+	return !!init && typeof init === "object" && "instance" in init;
 };
 
-// src/api/core/service.ts
+//#endregion
+//#region src/api/core/service.ts
 var ServiceError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "ServiceError";
-  }
-};
-var HttpMethod = {
-  Get: "GET",
-  Post: "POST",
-  Put: "PUT",
-  Delete: "DELETE"
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "ServiceError";
+	}
 };
-
-// src/api/schemas/account.ts
-var import_zod2 = require("zod");
-var DelegationStatus = {
-  Undelegated: "Undelegated",
-  Pending: "Pending",
-  Delegated: "Delegated",
-  Expired: "Expired",
-  Errored: "Errored"
+const HttpMethod = {
+	Get: "GET",
+	Post: "POST",
+	Put: "PUT",
+	Delete: "DELETE"
 };
-var delegationStatusValues = Object.values(DelegationStatus);
-var delegationStatusSchema = import_zod2.z.enum(delegationStatusValues);
-var delegationStatusRequestSchema = import_zod2.z.object({
-  address: import_zod2.z.string(),
-  chainId: import_zod2.z.number()
-});
-var delegationStatusResponseSchema = import_zod2.z.object({
-  delegationStatus: delegationStatusSchema
-});
-var delegationCreateRequestSchema = import_zod2.z.object({
-  signedAuthorization: import_zod2.z.string(),
-  signerAddress: import_zod2.z.string()
-});
-var delegationCreateResponseSchema = import_zod2.z.object({
-  success: import_zod2.z.boolean(),
-  transactionHash: import_zod2.z.string().optional(),
-  message: import_zod2.z.string().optional()
-});
-
-// src/api/schemas/activity.ts
-var import_zod8 = require("zod");
 
-// src/schemas/instruction.ts
-var import_zod4 = require("zod");
-
-// src/schemas/misc.ts
-var import_zod3 = require("zod");
-var DATE_REGEX = /^(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
-var DATE_ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
-var DATE_STANDARD_REGEX = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/(19|20)\d{2}$/;
-var TIME_REGEX = /^(0[1-9]|1[0-2]):[0-5][0-9]:[0-5][0-9] (AM|PM)$/;
-var regexSchema = (regex, message) => import_zod3.z.string().regex(regex, message);
-var nonEmptyStringSchema = import_zod3.z.string().min(1);
-var numberSchema = import_zod3.z.union([
-  import_zod3.z.number().finite(),
-  import_zod3.z.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)
-]);
-var decimalStringSchema = import_zod3.z.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), {
-  message: "Must be a valid decimal number"
-});
-var bigintSchema = import_zod3.z.union([
-  import_zod3.z.bigint(),
-  import_zod3.z.string().regex(/^-?\d+$/).transform(BigInt)
-]);
-var hexStringSchema = import_zod3.z.string().startsWith("0x").transform((val) => val);
-var dateSchema = regexSchema(DATE_REGEX);
-var dateISO8601Schema = regexSchema(DATE_ISO_8601_REGEX);
-var dateStandardSchema = regexSchema(DATE_STANDARD_REGEX);
-var timeSchema = regexSchema(TIME_REGEX);
-var Sort = {
-  Asc: "asc",
-  Desc: "desc"
+//#endregion
+//#region src/api/schemas/account.ts
+const DelegationStatus = {
+	Undelegated: "Undelegated",
+	Pending: "Pending",
+	Delegated: "Delegated",
+	Expired: "Expired",
+	Errored: "Errored"
 };
-var sortValues = Object.values(Sort);
-var vrsSchema = import_zod3.z.object({
-  v: import_zod3.z.number(),
-  r: import_zod3.z.string(),
-  s: import_zod3.z.string()
-});
-var eip2098SignatureSchema = import_zod3.z.object({
-  yParity: import_zod3.z.number(),
-  r: import_zod3.z.string(),
-  s: import_zod3.z.string()
+const delegationStatusValues = Object.values(DelegationStatus);
+const delegationStatusSchema = zod.z.enum(delegationStatusValues);
+const delegationStatusRequestSchema = zod.z.object({
+	address: zod.z.string(),
+	chainId: zod.z.number()
+});
+const delegationStatusResponseSchema = zod.z.object({ delegationStatus: delegationStatusSchema });
+const delegationCreateRequestSchema = zod.z.object({
+	signedAuthorization: zod.z.string(),
+	signerAddress: zod.z.string()
+});
+const delegationCreateResponseSchema = zod.z.object({
+	success: zod.z.boolean(),
+	transactionHash: zod.z.string().optional(),
+	message: zod.z.string().optional()
 });
 
-// src/schemas/instruction.ts
-var instructionIdSchema = hexStringSchema;
-var InstructionState = {
-  PendingActivation: "PendingActivation",
-  Active: "Active",
-  PendingDeactivation: "PendingDeactivation",
-  Deactivated: "Deactivated",
-  Errored: "Errored",
-  Completed: "Completed",
-  UserNotDelegated: "UserNotDelegated",
-  InFlight: "InFlight",
-  NotifyUser: "NotifyUser"
-};
-var instructionStateValues = Object.values(InstructionState);
-var instructionStateSchema = import_zod4.z.enum(instructionStateValues);
-var InstructionAction = {
-  RefuelERC20: "refuelERC20",
-  Refuel: "refuel",
-  Transfer: "transfer",
-  TransferERC20: "transferERC20",
-  UniswapV3ExactInput: "uniswapV3ExactInput",
-  Sweep: "sweep",
-  SweepERC20: "sweepERC20",
-  SweepCCTP: "sweepCCTP",
-  SweepUniswapV3: "sweepUniswapV3",
-  SweepDepositAccount: "sweepDepositAccount",
-  SweepDepositAccountERC20: "sweepDepositAccountERC20",
-  DeactivateInstruction: "deactivateInstruction",
-  SweepSkipCCTPDepositAccount: "sweepSkipCCTPDepositAccount"
+//#endregion
+//#region src/api/schemas/activity.ts
+const actionNameSchema = zod.z.enum(_otim_utils_schemas.instructionActionValues);
+/**
+* Human-readable labels for automation action names.
+*/
+const ACTION_NAME_LABELS = {
+	[_otim_utils_schemas.InstructionAction.Refuel]: "Refuel",
+	[_otim_utils_schemas.InstructionAction.RefuelERC20]: "Refuel",
+	[_otim_utils_schemas.InstructionAction.Transfer]: "Transfer",
+	[_otim_utils_schemas.InstructionAction.TransferERC20]: "Transfer",
+	[_otim_utils_schemas.InstructionAction.TransferCCTP]: "Transfer",
+	[_otim_utils_schemas.InstructionAction.Sweep]: "Sweep",
+	[_otim_utils_schemas.InstructionAction.SweepERC20]: "Sweep",
+	[_otim_utils_schemas.InstructionAction.SweepCCTP]: "Sweep",
+	[_otim_utils_schemas.InstructionAction.SweepUniswapV3]: "Trade",
+	[_otim_utils_schemas.InstructionAction.UniswapV3ExactInput]: "Trade",
+	[_otim_utils_schemas.InstructionAction.DepositERC4626]: "Deposit",
+	[_otim_utils_schemas.InstructionAction.SweepDepositERC4626]: "Deposit",
+	[_otim_utils_schemas.InstructionAction.WithdrawERC4626]: "Withdraw",
+	[_otim_utils_schemas.InstructionAction.SweepWithdrawERC4626]: "Withdraw",
+	[_otim_utils_schemas.InstructionAction.DeactivateInstruction]: "Deactivate",
+	[_otim_utils_schemas.InstructionAction.CallOnce]: "Call Once"
 };
-var instructionActionValues = Object.values(InstructionAction);
-var instructionActionSchema = import_zod4.z.enum(instructionActionValues);
-var InstructionScheduleStartType = {
-  Now: "now",
-  DateTime: "datetime"
+const DEFAULT_ACTION_LABEL = "–";
+/**
+* Human-readable labels for payment rails.
+*/
+const PAYMENT_RAIL_LABELS = {
+	ach_push: "ACH",
+	pix: "PIX",
+	sepa: "SEPA",
+	spei: "SPEI",
+	wire: "Wire"
 };
-var instructionScheduleStartValues = Object.values(
-  InstructionScheduleStartType
-);
-var baseStartSchema = import_zod4.z.object({
-  type: import_zod4.z.enum(instructionScheduleStartValues)
-});
-var nowStartSchema = baseStartSchema.extend({
-  type: import_zod4.z.literal(InstructionScheduleStartType.Now)
-});
-var dateTimeStartSchema = baseStartSchema.extend({
-  type: import_zod4.z.literal(InstructionScheduleStartType.DateTime),
-  startDate: dateStandardSchema,
-  startTime: import_zod4.z.string()
-});
-var instructionScheduleStartSchema = import_zod4.z.discriminatedUnion("type", [
-  nowStartSchema,
-  dateTimeStartSchema
-]);
-var InstructionScheduleRepeatType = {
-  UntilDeactivated: "until-deactivated",
-  MaxExecutions: "max-executions"
-};
-var instructionScheduleRepeatValues = Object.values(
-  InstructionScheduleRepeatType
-);
-var baseRepeatSchema = import_zod4.z.object({});
-var untilDeactivatedRepeatSchema = baseRepeatSchema.extend({
-  type: import_zod4.z.literal(InstructionScheduleRepeatType.UntilDeactivated)
-});
-var maxExecutionsRepeatSchema = baseRepeatSchema.extend({
-  type: import_zod4.z.literal(InstructionScheduleRepeatType.MaxExecutions),
-  maxExecutions: numberSchema
-});
-var instructionScheduleRepeatSchema = import_zod4.z.discriminatedUnion("type", [
-  untilDeactivatedRepeatSchema,
-  maxExecutionsRepeatSchema
-]);
-var InstructionScheduleRetryType = {
-  UntilDeactivated: "until-deactivated",
-  TimeLimited: "time-limited"
-};
-var instructionScheduleRetryValues = Object.values(
-  InstructionScheduleRetryType
-);
-var baseRetrySchema = import_zod4.z.object({});
-var untilDeactivatedRetrySchema = baseRetrySchema.extend({
-  type: import_zod4.z.literal(InstructionScheduleRetryType.UntilDeactivated)
-});
-var timeLimitedRetrySchema = baseRetrySchema.extend({
-  type: import_zod4.z.literal(InstructionScheduleRetryType.TimeLimited),
-  retryCount: numberSchema
-});
-var instructionScheduleRetrySchema = import_zod4.z.discriminatedUnion("type", [
-  untilDeactivatedRetrySchema,
-  timeLimitedRetrySchema
-]);
-var TimeUnit = {
-  None: "none",
-  Second: "second",
-  Minute: "minute",
-  Hour: "hour",
-  Day: "day",
-  Week: "week",
-  Month: "month"
-};
-var timeUnitValues = Object.values(TimeUnit);
-var timeUnitSchema = import_zod4.z.enum(timeUnitValues);
-var instructionExecutionStateSchema = import_zod4.z.object({
-  executionStatus: instructionStateSchema.optional(),
-  executionCounter: import_zod4.z.number().int().optional(),
-  lastExecuted: import_zod4.z.number().int().optional()
-});
-var instructionSchema = import_zod4.z.object({
-  instructionId: hexStringSchema,
-  createdAt: import_zod4.z.number().optional(),
-  startAt: import_zod4.z.string().nullish(),
-  interval: import_zod4.z.number().nullish(),
-  timeout: import_zod4.z.number().nullish(),
-  maxExecutions: import_zod4.z.number().nullish(),
-  executionState: instructionExecutionStateSchema.optional(),
-  actionName: import_zod4.z.string().optional(),
-  arguments: import_zod4.z.any(),
-  nickname: import_zod4.z.string().nullish(),
-  lastInstructedValue: import_zod4.z.string().optional(),
-  lastErrorCode: import_zod4.z.number().nullish(),
-  lastErrorMessage: import_zod4.z.string().nullish(),
-  totalInstructedValue: import_zod4.z.string().optional(),
-  instructedTokenAddress: hexStringSchema.nullish(),
-  chainId: import_zod4.z.number().nullish(),
-  chain: import_zod4.z.string().optional()
-});
-var instructionsSchema = import_zod4.z.array(instructionSchema);
-var instructionSummarySchema = import_zod4.z.object({
-  instructionId: hexStringSchema,
-  chainId: import_zod4.z.number().int(),
-  executionCount: import_zod4.z.number().int(),
-  onTimeCount: import_zod4.z.number().int(),
-  lateCount: import_zod4.z.number().int(),
-  wasActivatedDuring: import_zod4.z.boolean(),
-  amount: import_zod4.z.number().default(0),
-  instructedValue: import_zod4.z.string().nullish().default("0"),
-  instructedTokenAddress: import_zod4.z.string().nullish().default(null)
-});
-var instructionSummariesSchema = import_zod4.z.array(instructionSummarySchema);
-var instructionSummariesByDateSchema = import_zod4.z.record(
-  import_zod4.z.string(),
-  instructionSummariesSchema
-);
-var InstructionViewTimescale = {
-  Days: "days",
-  Hours: "hours",
-  Minutes: "minutes",
-  Seconds: "seconds"
-};
-var instructionViewTimescaleValues = Object.values(
-  InstructionViewTimescale
-);
-
-// src/schemas/payment.ts
-var import_zod5 = require("zod");
-var PaymentStatus = {
-  Due: "due",
-  NotDue: "not-due",
-  Paid: "paid"
+/**
+* Human-readable labels for virtual account event types.
+*/
+const VIRTUAL_ACCOUNT_EVENT_LABELS = {
+	funds_received: "Funds Received",
+	payment_submitted: "Payment Submitted",
+	payment_processed: "Payment Processed",
+	in_review: "In Review",
+	microdeposit: "Microdeposit",
+	funds_scheduled: "Funds Scheduled"
 };
-var PaymentSource = {
-  Bill: "Bill",
-  Stripe: "Stripe",
-  Clio: "Clio",
-  QuickBooks: "QuickBooks"
-};
-var paymentRequestSourceValues = [
-  PaymentSource.Bill,
-  PaymentSource.Stripe,
-  PaymentSource.Clio,
-  PaymentSource.QuickBooks
-];
-var paymentSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  fromUserId: import_zod5.z.string().nullable().optional(),
-  toUserId: import_zod5.z.string().nullable().optional(),
-  payerAddress: import_zod5.z.string().nullable().optional(),
-  ephemeralWalletAddress: import_zod5.z.string(),
-  ephemeralWalletId: import_zod5.z.string().optional(),
-  instructions: import_zod5.z.object({
-    ids: import_zod5.z.array(import_zod5.z.string()),
-    completionIds: import_zod5.z.array(import_zod5.z.string())
-  }).optional(),
-  metadata: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional(),
-  // UI-derived fields
-  status: import_zod5.z.union([
-    import_zod5.z.literal(PaymentStatus.Due),
-    import_zod5.z.literal(PaymentStatus.NotDue),
-    import_zod5.z.literal(PaymentStatus.Paid)
-  ]),
-  dueDate: import_zod5.z.string(),
-  amountDue: import_zod5.z.number(),
-  note: import_zod5.z.string().nullable().optional(),
-  address: import_zod5.z.string().nullable().optional(),
-  addedOn: import_zod5.z.string(),
-  source: import_zod5.z.union([
-    import_zod5.z.literal(PaymentSource.Bill),
-    import_zod5.z.literal(PaymentSource.Stripe),
-    import_zod5.z.literal(PaymentSource.Clio),
-    import_zod5.z.literal(PaymentSource.QuickBooks)
-  ]).nullish(),
-  attachmentUrl: import_zod5.z.string().url().nullable().optional(),
-  attachmentName: import_zod5.z.string().nullable().optional(),
-  fromAccountAddress: import_zod5.z.string().nullable().optional()
-});
-var PaymentsSchema = import_zod5.z.array(paymentSchema);
-
-// src/schemas/transaction.ts
-var import_zod6 = require("zod");
-var transactionSchema = import_zod6.z.object({
-  instructionId: instructionIdSchema,
-  transactionHash: hexStringSchema.optional(),
-  blockHash: import_zod6.z.string().nullable(),
-  transactionStatus: import_zod6.z.string(),
-  error: import_zod6.z.string().nullish(),
-  startedAt: import_zod6.z.string(),
-  startedAtBlock: import_zod6.z.number(),
-  finishedAt: import_zod6.z.string().nullable(),
-  finishedAtBlock: import_zod6.z.number().nullable(),
-  amount: import_zod6.z.object({ value: import_zod6.z.number(), token: import_zod6.z.string() }).nullish(),
-  instructedValue: import_zod6.z.string(),
-  instructedTokenAddress: import_zod6.z.string().nullable(),
-  executionNum: import_zod6.z.number(),
-  chainId: import_zod6.z.number().nullish(),
-  chain: import_zod6.z.string().optional()
-});
-var transactionWithValidAmountSchema = transactionSchema.extend({
-  amount: import_zod6.z.object({
-    value: import_zod6.z.number(),
-    token: import_zod6.z.string()
-  })
-});
-var transactionsSchema = import_zod6.z.array(transactionSchema);
-
-// src/schemas/user.ts
-var import_zod7 = require("zod");
-var entityIdSchema = import_zod7.z.string().uuid();
-var addressSchema = import_zod7.z.string().regex(/^0x[a-fA-F0-9]{40}$/).transform((v) => v.toLowerCase());
-var userPreferencesSchema = import_zod7.z.object({
-  chainId: import_zod7.z.number().optional(),
-  tokenSymbol: import_zod7.z.string().optional(),
-  localCurrency: import_zod7.z.string().optional()
-});
-var userSchema = import_zod7.z.object({
-  id: entityIdSchema,
-  address: addressSchema,
-  createdAt: import_zod7.z.string(),
-  updatedAt: import_zod7.z.string(),
-  preferences: userPreferencesSchema.optional(),
-  isDeveloper: import_zod7.z.boolean(),
-  developerPublicKey: import_zod7.z.string().nullable().optional()
-});
-
-// src/api/schemas/activity.ts
-var actionNameSchema = import_zod8.z.enum([
-  "refuel",
-  "transfer",
-  "refuelERC20",
-  "transferERC20",
-  "uniswapV3ExactInput",
-  "deactivateInstruction",
-  "sweepCCTP",
-  "transferCCTP",
-  "sweep",
-  "sweepERC20",
-  "sweepUniswapV3",
-  "depositERC4626",
-  "sweepDepositERC4626",
-  "withdrawERC4626",
-  "sweepWithdrawERC4626",
-  "callOnce"
-]);
-var transferFieldsSchema = import_zod8.z.object({
-  token: hexStringSchema,
-  from: hexStringSchema,
-  to: hexStringSchema,
-  value: hexStringSchema
-});
-var swapFieldsSchema = import_zod8.z.object({
-  poolAddress: hexStringSchema,
-  fromToken: hexStringSchema,
-  toToken: hexStringSchema,
-  from: hexStringSchema,
-  to: hexStringSchema,
-  fromAmount: hexStringSchema,
-  toAmount: hexStringSchema
-});
-var cctpBurnFieldsSchema = import_zod8.z.object({
-  token: hexStringSchema,
-  from: hexStringSchema,
-  mintRecipient: hexStringSchema,
-  destinationDomain: hexStringSchema,
-  value: hexStringSchema
-});
-var erc4626DepositFieldsSchema = import_zod8.z.object({
-  vault: hexStringSchema,
-  token: hexStringSchema,
-  from: hexStringSchema,
-  owner: hexStringSchema,
-  value: hexStringSchema,
-  shares: hexStringSchema
-});
-var erc4626WithdrawFieldsSchema = import_zod8.z.object({
-  vault: hexStringSchema,
-  token: hexStringSchema,
-  from: hexStringSchema,
-  to: hexStringSchema,
-  value: hexStringSchema,
-  shares: hexStringSchema
-});
-var activityDataSchema = import_zod8.z.union([
-  import_zod8.z.object({ transfer: transferFieldsSchema }),
-  import_zod8.z.object({ swap: swapFieldsSchema }),
-  import_zod8.z.object({ cctpBurn: cctpBurnFieldsSchema }),
-  import_zod8.z.object({ erc4626Deposit: erc4626DepositFieldsSchema }),
-  import_zod8.z.object({ erc4626Withdraw: erc4626WithdrawFieldsSchema })
+/**
+* Formats a payment rail value to a human-readable label.
+*/
+function formatPaymentRail(paymentRail) {
+	if (!paymentRail) return DEFAULT_ACTION_LABEL;
+	const label = PAYMENT_RAIL_LABELS[paymentRail.toLowerCase()];
+	if (label) return label;
+	return paymentRail.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+/**
+* Formats an action name to a human-readable label.
+*/
+function formatActionName(actionName, source) {
+	if (!actionName) return DEFAULT_ACTION_LABEL;
+	if (actionName.startsWith("virtual_account_")) {
+		if (source?.payment_rail) return formatPaymentRail(source.payment_rail);
+		const eventType = actionName.replace("virtual_account_", "");
+		const label = VIRTUAL_ACCOUNT_EVENT_LABELS[eventType];
+		if (label) return label;
+		return eventType.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+	}
+	return ACTION_NAME_LABELS[actionName] ?? DEFAULT_ACTION_LABEL;
+}
+const transferFieldsSchema = zod.z.object({
+	token: _otim_utils_schemas.hexStringSchema,
+	from: _otim_utils_schemas.hexStringSchema,
+	to: _otim_utils_schemas.hexStringSchema,
+	value: _otim_utils_schemas.hexStringSchema
+});
+const swapFieldsSchema = zod.z.object({
+	poolAddress: _otim_utils_schemas.hexStringSchema,
+	fromToken: _otim_utils_schemas.hexStringSchema,
+	toToken: _otim_utils_schemas.hexStringSchema,
+	from: _otim_utils_schemas.hexStringSchema,
+	to: _otim_utils_schemas.hexStringSchema,
+	fromAmount: _otim_utils_schemas.hexStringSchema,
+	toAmount: _otim_utils_schemas.hexStringSchema
+});
+const cctpBurnFieldsSchema = zod.z.object({
+	token: _otim_utils_schemas.hexStringSchema,
+	from: _otim_utils_schemas.hexStringSchema,
+	mintRecipient: _otim_utils_schemas.hexStringSchema,
+	destinationDomain: _otim_utils_schemas.hexStringSchema,
+	value: _otim_utils_schemas.hexStringSchema
+});
+const erc4626DepositFieldsSchema = zod.z.object({
+	vault: _otim_utils_schemas.hexStringSchema,
+	token: _otim_utils_schemas.hexStringSchema,
+	from: _otim_utils_schemas.hexStringSchema,
+	owner: _otim_utils_schemas.hexStringSchema,
+	value: _otim_utils_schemas.hexStringSchema,
+	shares: _otim_utils_schemas.hexStringSchema
+});
+const erc4626WithdrawFieldsSchema = zod.z.object({
+	vault: _otim_utils_schemas.hexStringSchema,
+	token: _otim_utils_schemas.hexStringSchema,
+	from: _otim_utils_schemas.hexStringSchema,
+	to: _otim_utils_schemas.hexStringSchema,
+	value: _otim_utils_schemas.hexStringSchema,
+	shares: _otim_utils_schemas.hexStringSchema
+});
+const activityDataSchema = zod.z.union([
+	zod.z.object({ transfer: transferFieldsSchema }),
+	zod.z.object({ swap: swapFieldsSchema }),
+	zod.z.object({ cctpBurn: cctpBurnFieldsSchema }),
+	zod.z.object({ erc4626Deposit: erc4626DepositFieldsSchema }),
+	zod.z.object({ erc4626Withdraw: erc4626WithdrawFieldsSchema })
 ]);
-var activityRecordSchema = import_zod8.z.object({
-  actionName: actionNameSchema,
-  blockTimestamp: numberSchema,
-  transactionHash: hexStringSchema,
-  activity: activityDataSchema,
-  instructionId: hexStringSchema.nullable(),
-  executionCount: import_zod8.z.number().nullable()
-});
-var getInstructionActivityRequestSchema = import_zod8.z.object({
-  chainId: import_zod8.z.number(),
-  actionNames: import_zod8.z.array(actionNameSchema),
-  page: numberSchema.optional(),
-  perPage: numberSchema.optional()
-});
-var getInstructionActivityResponseSchema = import_zod8.z.array(activityRecordSchema);
+const activityRecordSchema = zod.z.object({
+	actionName: actionNameSchema,
+	blockTimestamp: _otim_utils_schemas.numberSchema,
+	transactionHash: _otim_utils_schemas.hexStringSchema,
+	activity: activityDataSchema,
+	instructionId: _otim_utils_schemas.hexStringSchema.nullable(),
+	executionCount: zod.z.number().nullable()
+});
+const getInstructionActivityRequestSchema = zod.z.object({
+	chainId: zod.z.number(),
+	actionNames: zod.z.array(actionNameSchema),
+	page: _otim_utils_schemas.numberSchema.optional(),
+	perPage: _otim_utils_schemas.numberSchema.optional()
+});
+const getInstructionActivityResponseSchema = zod.z.array(activityRecordSchema);
 
-// src/api/schemas/auth.ts
-var import_zod9 = require("zod");
-var authLoginRequestSchema = import_zod9.z.object({
-  siwe: import_zod9.z.string(),
-  signature: vrsSchema
-});
-var authLoginResponseSchema = import_zod9.z.object({
-  authorization: import_zod9.z.string(),
-  user: userSchema
-});
-var turnkeyVerificationRequestSchema = import_zod9.z.object({
-  email: import_zod9.z.string().email()
-});
-var turnkeyVerificationResponseSchema = import_zod9.z.object({
-  isLogin: import_zod9.z.boolean()
-});
-var attestationSchema = import_zod9.z.object({
-  credentialId: import_zod9.z.string(),
-  clientDataJson: import_zod9.z.string(),
-  attestationObject: import_zod9.z.string(),
-  transports: import_zod9.z.array(import_zod9.z.string()).optional()
-});
-var turnkeyLoginRequestSchema = import_zod9.z.object({
-  email: import_zod9.z.email(),
-  verificationCode: import_zod9.z.coerce.number().int().min(1e5).max(999999),
-  passkeyChallenge: import_zod9.z.string().optional(),
-  attestation: attestationSchema.optional()
-});
-var turnkeyLoginResponseSchema = import_zod9.z.object({
-  email: import_zod9.z.string(),
-  subOrgId: import_zod9.z.string(),
-  walletAddress: import_zod9.z.string(),
-  isLogin: import_zod9.z.boolean().optional()
-});
-var meResponseSchema = userSchema;
-var sessionTokenRequestSchema = import_zod9.z.object({
-  sessionToken: import_zod9.z.string()
-});
-var sessionTokenResponseSchema = import_zod9.z.object({
-  success: import_zod9.z.boolean()
-});
-var sessionVerifyResponseSchema = import_zod9.z.object({
-  authenticated: import_zod9.z.boolean(),
-  hasSessionToken: import_zod9.z.boolean()
-});
-var whitelistCheckRequestSchema = import_zod9.z.object({
-  email: import_zod9.z.string().email()
-});
-var whitelistCheckResponseSchema = import_zod9.z.object({
-  isAllowed: import_zod9.z.boolean(),
-  message: import_zod9.z.string().optional()
-});
-var addressWhitelistCheckRequestSchema = import_zod9.z.object({
-  address: import_zod9.z.string()
-});
-var addressWhitelistCheckResponseSchema = import_zod9.z.object({
-  isAllowed: import_zod9.z.boolean(),
-  message: import_zod9.z.string().optional()
-});
-var getCurrentUserResponseSchema = import_zod9.z.object({
-  data: userSchema
+//#endregion
+//#region src/api/schemas/auth.ts
+const authLoginRequestSchema = zod.z.object({
+	siwe: zod.z.string(),
+	signature: _otim_utils_schemas.vrsSchema
+});
+const authLoginResponseSchema = zod.z.object({
+	authorization: zod.z.string(),
+	user: _otim_utils_schemas.userSchema
+});
+const turnkeyVerificationRequestSchema = zod.z.object({ email: zod.z.string().email() });
+const turnkeyVerificationResponseSchema = zod.z.object({
+	isLogin: zod.z.boolean(),
+	codeAlreadyExists: zod.z.boolean().optional()
+});
+const attestationSchema = zod.z.object({
+	credentialId: zod.z.string(),
+	clientDataJson: zod.z.string(),
+	attestationObject: zod.z.string(),
+	transports: zod.z.array(zod.z.string()).optional()
+});
+const turnkeyLoginRequestSchema = zod.z.object({
+	email: zod.z.email(),
+	verificationCode: zod.z.coerce.number().int().min(1e5).max(999999),
+	passkeyChallenge: zod.z.string().optional(),
+	attestation: attestationSchema.optional()
+});
+const turnkeyLoginResponseSchema = zod.z.object({
+	email: zod.z.string(),
+	subOrgId: zod.z.string(),
+	walletAddress: zod.z.string(),
+	isLogin: zod.z.boolean().optional()
+});
+const meResponseSchema = _otim_utils_schemas.userSchema;
+const sessionTokenRequestSchema = zod.z.object({
+	sessionToken: zod.z.string(),
+	userId: zod.z.string()
+});
+const sessionTokenResponseSchema = zod.z.object({ success: zod.z.boolean() });
+const sessionVerifyResponseSchema = zod.z.object({
+	authenticated: zod.z.boolean(),
+	hasSessionToken: zod.z.boolean()
+});
+/**
+* @todo
+* - Remove later, this is a temporary schema for the whitelist check
+*/
+const whitelistCheckRequestSchema = zod.z.object({ email: zod.z.string().email() });
+const whitelistCheckResponseSchema = zod.z.object({
+	isAllowed: zod.z.boolean(),
+	message: zod.z.string().optional()
+});
+const addressWhitelistCheckRequestSchema = zod.z.object({ address: zod.z.string() });
+const addressWhitelistCheckResponseSchema = zod.z.object({
+	isAllowed: zod.z.boolean(),
+	message: zod.z.string().optional()
 });
 
-// src/api/schemas/chain.ts
-var import_zod10 = require("zod");
-var chainIdSchema = import_zod10.z.object({
-  chainId: import_zod10.z.number().nullable()
-});
-var setChainIdSchema = import_zod10.z.object({
-  chainId: import_zod10.z.number().positive()
-});
-var chainSuccessResponseSchema = import_zod10.z.object({
-  success: import_zod10.z.boolean(),
-  chainId: import_zod10.z.number().optional()
+//#endregion
+//#region src/api/schemas/chain.ts
+const chainIdSchema = zod.z.object({ chainId: zod.z.number().nullable() });
+const setChainIdSchema = zod.z.object({ chainId: zod.z.number().positive() });
+const chainSuccessResponseSchema = zod.z.object({
+	success: zod.z.boolean(),
+	chainId: zod.z.number().optional()
 });
 
-// src/api/schemas/config.ts
-var import_zod11 = require("zod");
-var getDelegateAddressSchema = import_zod11.z.object({
-  chainId: import_zod11.z.number()
-});
-var getDelegateAddressResponseSchema = import_zod11.z.object({
-  otimDelegateAddress: import_zod11.z.string()
-});
-var getConfigTokensRequestParametersSchema = import_zod11.z.object({
-  chainId: import_zod11.z.number()
-});
-var getConfigTokensResponseSchema = import_zod11.z.object({
-  tokens: import_zod11.z.array(
-    import_zod11.z.object({
-      symbol: import_zod11.z.any(),
-      address: hexStringSchema
-    })
-  )
-});
-var getConfigChainsResponseSchema = import_zod11.z.unknown();
-var getMaxPriorityFeePerGasEstimateSchema = import_zod11.z.object({
-  chainId: import_zod11.z.number()
-});
-var getMaxPriorityFeePerGasEstimateResponseSchema = import_zod11.z.object({
-  slowMaxPriorityFeeEstimate: import_zod11.z.number(),
-  normalMaxPriorityFeeEstimate: import_zod11.z.number(),
-  fastMaxPriorityFeeEstimate: import_zod11.z.number()
+//#endregion
+//#region src/api/schemas/config.ts
+const getDelegateAddressSchema = zod.z.object({ chainId: zod.z.number() });
+const getDelegateAddressResponseSchema = zod.z.object({ otimDelegateAddress: zod.z.string() });
+const getConfigTokensRequestParametersSchema = zod.z.object({ chainId: zod.z.number() });
+const getConfigTokensResponseSchema = zod.z.object({ tokens: zod.z.array(zod.z.object({
+	symbol: zod.z.any(),
+	address: _otim_utils_schemas.hexStringSchema
+})) });
+const getConfigChainsResponseSchema = zod.z.unknown();
+const getMaxPriorityFeePerGasEstimateSchema = zod.z.object({ chainId: zod.z.number() });
+const getMaxPriorityFeePerGasEstimateResponseSchema = zod.z.object({
+	slowMaxPriorityFeeEstimate: zod.z.number(),
+	normalMaxPriorityFeeEstimate: zod.z.number(),
+	fastMaxPriorityFeeEstimate: zod.z.number()
 });
 
-// src/api/schemas/contacts.ts
-var import_zod12 = require("zod");
-var newContactRequestSchema = import_zod12.z.object({
-  address: hexStringSchema,
-  name: import_zod12.z.string()
-});
-var getContactsRequestSchema = import_zod12.z.object({
-  perPage: numberSchema.optional(),
-  page: numberSchema.optional()
-});
-var contactSchema = import_zod12.z.object({
-  userId: import_zod12.z.string(),
-  address: hexStringSchema,
-  name: import_zod12.z.string(),
-  createdAt: import_zod12.z.string(),
-  updatedAt: import_zod12.z.string()
-});
-var getContactsResponseSchema = import_zod12.z.array(contactSchema);
+//#endregion
+//#region src/api/schemas/contacts.ts
+const newContactRequestSchema = zod.z.object({
+	address: _otim_utils_schemas.hexStringSchema,
+	name: zod.z.string()
+});
+const getContactsRequestSchema = zod.z.object({
+	perPage: _otim_utils_schemas.numberSchema.optional(),
+	page: _otim_utils_schemas.numberSchema.optional()
+});
+const contactSchema = zod.z.object({
+	userId: zod.z.string(),
+	address: _otim_utils_schemas.hexStringSchema,
+	name: zod.z.string(),
+	createdAt: zod.z.string(),
+	updatedAt: zod.z.string()
+});
+const getContactsResponseSchema = zod.z.array(contactSchema);
 
-// src/api/schemas/instruction.ts
-var import_zod13 = require("zod");
-var feeSchema = import_zod13.z.object({
-  executionFee: hexStringSchema,
-  maxBaseFeePerGas: hexStringSchema,
-  maxPriorityFeePerGas: hexStringSchema,
-  token: hexStringSchema
-});
-var scheduleSchema = import_zod13.z.object({
-  startAt: numberSchema,
-  startBy: numberSchema,
-  interval: numberSchema,
-  timeout: numberSchema
-});
-var baseActionArgumentsSchema = import_zod13.z.object({
-  target: hexStringSchema,
-  fee: feeSchema,
-  token: hexStringSchema
-});
-var refuelActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  threshold: numberSchema,
-  endBalance: numberSchema,
-  gasLimit: numberSchema
-});
-var refuelERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  threshold: numberSchema,
-  endBalance: numberSchema,
-  gasLimit: numberSchema
-});
-var transferActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  value: numberSchema,
-  gasLimit: numberSchema,
-  schedule: scheduleSchema
-});
-var transferERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  value: numberSchema,
-  gasLimit: numberSchema,
-  schedule: scheduleSchema
-});
-var sweepDepositAccountActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  threshold: numberSchema,
-  recipient: hexStringSchema,
-  depositorAddress: hexStringSchema
-});
-var sweepDepositAccountERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  threshold: numberSchema,
-  recipient: hexStringSchema,
-  depositorAddress: hexStringSchema
-});
-var uniswapV3ExactInputActionArgumentsSchema = import_zod13.z.object({
-  tokenIn: hexStringSchema,
-  tokenOut: hexStringSchema,
-  amountIn: numberSchema,
-  floorAmountOut: numberSchema,
-  feeTier: import_zod13.z.string(),
-  recipient: hexStringSchema,
-  meanPriceLookBack: numberSchema,
-  maxPriceDeviationBps: numberSchema,
-  fee: feeSchema,
-  schedule: scheduleSchema
-});
-var deactivateInstructionActionArgumentsSchema = import_zod13.z.object({
-  instructionId: hexStringSchema,
-  fee: feeSchema
-});
-var actionArgumentsSchema = import_zod13.z.union([
-  refuelActionArgumentsSchema,
-  refuelERC20ActionArgumentsSchema,
-  transferActionArgumentsSchema,
-  transferERC20ActionArgumentsSchema,
-  sweepDepositAccountActionArgumentsSchema,
-  sweepDepositAccountERC20ActionArgumentsSchema,
-  uniswapV3ExactInputActionArgumentsSchema,
-  deactivateInstructionActionArgumentsSchema
+//#endregion
+//#region src/api/schemas/instruction.ts
+const feeSchema = zod.z.object({
+	executionFee: _otim_utils_schemas.hexStringSchema,
+	maxBaseFeePerGas: _otim_utils_schemas.hexStringSchema,
+	maxPriorityFeePerGas: _otim_utils_schemas.hexStringSchema,
+	token: _otim_utils_schemas.hexStringSchema
+});
+const scheduleSchema = zod.z.object({
+	startAt: _otim_utils_schemas.numberSchema,
+	startBy: _otim_utils_schemas.numberSchema,
+	interval: _otim_utils_schemas.numberSchema,
+	timeout: _otim_utils_schemas.numberSchema
+});
+const baseActionArgumentsSchema = zod.z.object({
+	target: _otim_utils_schemas.hexStringSchema,
+	fee: feeSchema,
+	token: _otim_utils_schemas.hexStringSchema
+});
+const refuelActionArgumentsSchema = baseActionArgumentsSchema.extend({
+	threshold: _otim_utils_schemas.numberSchema,
+	endBalance: _otim_utils_schemas.numberSchema,
+	gasLimit: _otim_utils_schemas.numberSchema
+});
+const refuelERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
+	threshold: _otim_utils_schemas.numberSchema,
+	endBalance: _otim_utils_schemas.numberSchema,
+	gasLimit: _otim_utils_schemas.numberSchema
+});
+const transferActionArgumentsSchema = baseActionArgumentsSchema.extend({
+	value: _otim_utils_schemas.numberSchema,
+	gasLimit: _otim_utils_schemas.numberSchema,
+	schedule: scheduleSchema
+});
+const transferERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
+	value: _otim_utils_schemas.numberSchema,
+	gasLimit: _otim_utils_schemas.numberSchema,
+	schedule: scheduleSchema
+});
+const uniswapV3ExactInputActionArgumentsSchema = zod.z.object({
+	tokenIn: _otim_utils_schemas.hexStringSchema,
+	tokenOut: _otim_utils_schemas.hexStringSchema,
+	amountIn: _otim_utils_schemas.numberSchema,
+	floorAmountOut: _otim_utils_schemas.numberSchema,
+	feeTier: zod.z.string(),
+	recipient: _otim_utils_schemas.hexStringSchema,
+	meanPriceLookBack: _otim_utils_schemas.numberSchema,
+	maxPriceDeviationBps: _otim_utils_schemas.numberSchema,
+	fee: feeSchema,
+	schedule: scheduleSchema
+});
+const deactivateInstructionActionArgumentsSchema = zod.z.object({
+	instructionId: _otim_utils_schemas.hexStringSchema,
+	fee: feeSchema
+});
+const depositERC4626ActionArgumentsSchema = zod.z.object({
+	vault: _otim_utils_schemas.hexStringSchema,
+	recipient: _otim_utils_schemas.hexStringSchema,
+	value: _otim_utils_schemas.numberSchema,
+	minDeposit: _otim_utils_schemas.numberSchema,
+	minTotalShares: _otim_utils_schemas.numberSchema,
+	schedule: scheduleSchema,
+	fee: feeSchema
+});
+const sweepDepositERC4626ActionArgumentsSchema = zod.z.object({
+	vault: _otim_utils_schemas.hexStringSchema,
+	recipient: _otim_utils_schemas.hexStringSchema,
+	threshold: _otim_utils_schemas.numberSchema,
+	endBalance: _otim_utils_schemas.numberSchema,
+	minDeposit: _otim_utils_schemas.numberSchema,
+	minTotalShares: _otim_utils_schemas.numberSchema,
+	fee: feeSchema
+});
+const withdrawERC4626ActionArgumentsSchema = zod.z.object({
+	vault: _otim_utils_schemas.hexStringSchema,
+	recipient: _otim_utils_schemas.hexStringSchema,
+	value: _otim_utils_schemas.numberSchema,
+	minWithdraw: _otim_utils_schemas.numberSchema,
+	schedule: scheduleSchema,
+	fee: feeSchema
+});
+const sweepWithdrawERC4626ActionArgumentsSchema = zod.z.object({
+	vault: _otim_utils_schemas.hexStringSchema,
+	recipient: _otim_utils_schemas.hexStringSchema,
+	threshold: _otim_utils_schemas.numberSchema,
+	endBalance: _otim_utils_schemas.numberSchema,
+	minWithdraw: _otim_utils_schemas.numberSchema,
+	fee: feeSchema
+});
+const actionArgumentsSchema = zod.z.union([
+	refuelActionArgumentsSchema,
+	refuelERC20ActionArgumentsSchema,
+	transferActionArgumentsSchema,
+	transferERC20ActionArgumentsSchema,
+	uniswapV3ExactInputActionArgumentsSchema,
+	deactivateInstructionActionArgumentsSchema,
+	depositERC4626ActionArgumentsSchema,
+	sweepDepositERC4626ActionArgumentsSchema,
+	withdrawERC4626ActionArgumentsSchema,
+	sweepWithdrawERC4626ActionArgumentsSchema
 ]);
-var feeResponseSchema = import_zod13.z.object({
-  token: hexStringSchema,
-  executionFee: hexStringSchema,
-  maxBaseFeePerGas: hexStringSchema,
-  maxPriorityFeePerGas: hexStringSchema
-});
-var scheduleResponseSchema = import_zod13.z.object({
-  startAt: hexStringSchema,
-  startBy: hexStringSchema,
-  interval: hexStringSchema,
-  timeout: hexStringSchema
-});
-var refuelActionResponseSchema = import_zod13.z.object({
-  target: hexStringSchema,
-  threshold: hexStringSchema,
-  endBalance: hexStringSchema,
-  gasLimit: hexStringSchema,
-  fee: feeResponseSchema
-});
-var transferActionResponseSchema = import_zod13.z.object({
-  target: hexStringSchema,
-  value: hexStringSchema,
-  gasLimit: hexStringSchema,
-  schedule: scheduleResponseSchema,
-  fee: feeResponseSchema
-});
-var refuelERC20ActionResponseSchema = import_zod13.z.object({
-  token: hexStringSchema,
-  target: hexStringSchema,
-  threshold: hexStringSchema,
-  endBalance: hexStringSchema,
-  fee: feeResponseSchema
-});
-var transferERC20ActionResponseSchema = import_zod13.z.object({
-  token: hexStringSchema,
-  target: hexStringSchema,
-  value: hexStringSchema,
-  schedule: scheduleResponseSchema,
-  fee: feeResponseSchema
-});
-var actionArgumentsResponseSchema = import_zod13.z.union([
-  refuelActionResponseSchema,
-  transferActionResponseSchema,
-  refuelERC20ActionResponseSchema,
-  transferERC20ActionResponseSchema
+const feeResponseSchema$1 = zod.z.object({
+	token: _otim_utils_schemas.hexStringSchema,
+	executionFee: _otim_utils_schemas.hexStringSchema,
+	maxBaseFeePerGas: _otim_utils_schemas.hexStringSchema,
+	maxPriorityFeePerGas: _otim_utils_schemas.hexStringSchema
+});
+const scheduleResponseSchema = zod.z.object({
+	startAt: _otim_utils_schemas.hexStringSchema,
+	startBy: _otim_utils_schemas.hexStringSchema,
+	interval: _otim_utils_schemas.hexStringSchema,
+	timeout: _otim_utils_schemas.hexStringSchema
+});
+const refuelActionResponseSchema = zod.z.object({
+	target: _otim_utils_schemas.hexStringSchema,
+	threshold: _otim_utils_schemas.hexStringSchema,
+	endBalance: _otim_utils_schemas.hexStringSchema,
+	gasLimit: _otim_utils_schemas.hexStringSchema,
+	fee: feeResponseSchema$1
+});
+const transferActionResponseSchema = zod.z.object({
+	target: _otim_utils_schemas.hexStringSchema,
+	value: _otim_utils_schemas.hexStringSchema,
+	gasLimit: _otim_utils_schemas.hexStringSchema,
+	schedule: scheduleResponseSchema,
+	fee: feeResponseSchema$1
+});
+const refuelERC20ActionResponseSchema = zod.z.object({
+	token: _otim_utils_schemas.hexStringSchema,
+	target: _otim_utils_schemas.hexStringSchema,
+	threshold: _otim_utils_schemas.hexStringSchema,
+	endBalance: _otim_utils_schemas.hexStringSchema,
+	fee: feeResponseSchema$1
+});
+const transferERC20ActionResponseSchema = zod.z.object({
+	token: _otim_utils_schemas.hexStringSchema,
+	target: _otim_utils_schemas.hexStringSchema,
+	value: _otim_utils_schemas.hexStringSchema,
+	schedule: scheduleResponseSchema,
+	fee: feeResponseSchema$1
+});
+const actionArgumentsResponseSchema = zod.z.union([
+	refuelActionResponseSchema,
+	transferActionResponseSchema,
+	refuelERC20ActionResponseSchema,
+	transferERC20ActionResponseSchema
 ]);
-var instructionBuildSchema = import_zod13.z.object({
-  action: hexStringSchema,
-  arguments: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  salt: hexStringSchema,
-  nickname: import_zod13.z.string().nullish()
-});
-var instructionGetAllRequestSchema = import_zod13.z.object({
-  address: hexStringSchema,
-  chainId: import_zod13.z.number(),
-  page: import_zod13.z.number().optional(),
-  perPage: import_zod13.z.number().optional()
-});
-var instructionGetAllResponseSchema = import_zod13.z.array(instructionSchema);
-var instructionBuildRequestSchema = import_zod13.z.object({
-  address: hexStringSchema,
-  chainId: import_zod13.z.number(),
-  salt: import_zod13.z.number(),
-  maxExecutions: import_zod13.z.number(),
-  actionArguments: import_zod13.z.record(import_zod13.z.string(), actionArgumentsSchema).refine(
-    (args) => {
-      const keys = Object.keys(args);
-      return keys.length === 1 && instructionActionValues.includes(
-        keys[0]
-      );
-    },
-    {
-      message: "actionArguments must contain exactly one valid instruction action"
-    }
-  )
-});
-var instructionActivateRequestSchema = import_zod13.z.object({
-  nickname: import_zod13.z.string().optional(),
-  address: hexStringSchema,
-  chainId: import_zod13.z.number(),
-  salt: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  action: hexStringSchema,
-  arguments: hexStringSchema,
-  activationSignature: eip2098SignatureSchema
-});
-var instructionActivateResponseSchema = import_zod13.z.object({
-  instructionId: hexStringSchema
-});
-var instructionDeactivateRequestSchema = import_zod13.z.object({
-  address: hexStringSchema,
-  chainId: import_zod13.z.number(),
-  deactivation: import_zod13.z.object({
-    instructionId: hexStringSchema
-  }),
-  deactivationSignature: eip2098SignatureSchema
-});
-var instructionDeactivateResponseSchema = import_zod13.z.unknown();
-var instructionDetailsRequestSchema = import_zod13.z.object({
-  address: hexStringSchema,
-  instructionId: hexStringSchema,
-  chainId: import_zod13.z.number()
-});
-var instructionDetailsResponseSchema = import_zod13.z.object({
-  action: hexStringSchema,
-  actionArguments: import_zod13.z.any(),
-  actionName: import_zod13.z.string().nullish(),
-  salt: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  nickname: import_zod13.z.string().nullish(),
-  lastErrorCode: import_zod13.z.number().int(),
-  lastErrorMessage: import_zod13.z.string().nullish()
-});
-var instructionGetRulesRequestSchema = import_zod13.z.object({
-  chainId: import_zod13.z.number(),
-  page: import_zod13.z.number().optional(),
-  perPage: import_zod13.z.number().optional()
-});
-var instructionGetRulesResponseSchema = import_zod13.z.array(
-  instructionSchema
-);
+const instructionBuildSchema = zod.z.object({
+	action: _otim_utils_schemas.hexStringSchema,
+	arguments: _otim_utils_schemas.hexStringSchema,
+	maxExecutions: _otim_utils_schemas.hexStringSchema,
+	salt: _otim_utils_schemas.hexStringSchema,
+	nickname: zod.z.string().nullish()
+});
+const instructionGetAllRequestSchema = zod.z.object({
+	address: _otim_utils_schemas.hexStringSchema,
+	chainId: zod.z.number(),
+	actionName: zod.z.string().optional(),
+	page: zod.z.number().optional(),
+	perPage: zod.z.number().optional()
+});
+const instructionGetAllResponseSchema = zod.z.array(_otim_utils_schemas.instructionSchema);
+const instructionBuildRequestSchema = zod.z.object({
+	address: _otim_utils_schemas.hexStringSchema,
+	chainId: zod.z.number(),
+	salt: zod.z.number(),
+	maxExecutions: zod.z.number(),
+	actionArguments: zod.z.record(zod.z.string(), actionArgumentsSchema).refine((args) => {
+		const keys = Object.keys(args);
+		return keys.length === 1 && _otim_utils_schemas.instructionActionValues.includes(keys[0]);
+	}, { message: "actionArguments must contain exactly one valid instruction action" })
+});
+const instructionActivateRequestSchema = zod.z.object({
+	nickname: zod.z.string().optional(),
+	address: _otim_utils_schemas.hexStringSchema,
+	chainId: zod.z.number(),
+	salt: _otim_utils_schemas.hexStringSchema,
+	maxExecutions: _otim_utils_schemas.hexStringSchema,
+	action: _otim_utils_schemas.hexStringSchema,
+	arguments: _otim_utils_schemas.hexStringSchema,
+	activationSignature: _otim_utils_schemas.eip2098SignatureSchema
+});
+const instructionActivateResponseSchema = zod.z.object({ instructionId: _otim_utils_schemas.hexStringSchema });
+const instructionDeactivateRequestSchema = zod.z.object({
+	address: _otim_utils_schemas.hexStringSchema,
+	chainId: zod.z.number(),
+	deactivation: zod.z.object({ instructionId: _otim_utils_schemas.hexStringSchema }),
+	deactivationSignature: _otim_utils_schemas.eip2098SignatureSchema
+});
+const instructionDeactivateResponseSchema = zod.z.unknown();
+const instructionDetailsRequestSchema = zod.z.object({
+	address: _otim_utils_schemas.hexStringSchema,
+	instructionId: _otim_utils_schemas.hexStringSchema,
+	chainId: zod.z.number()
+});
+const instructionDetailsResponseSchema = zod.z.object({
+	action: _otim_utils_schemas.hexStringSchema,
+	actionArguments: zod.z.any(),
+	actionName: zod.z.string().nullish(),
+	salt: _otim_utils_schemas.hexStringSchema,
+	maxExecutions: _otim_utils_schemas.hexStringSchema,
+	nickname: zod.z.string().nullish(),
+	lastErrorCode: zod.z.number().int(),
+	lastErrorMessage: zod.z.string().nullish()
+});
+const instructionGetRulesRequestSchema = zod.z.object({
+	chainId: zod.z.number(),
+	page: zod.z.number().optional(),
+	perPage: zod.z.number().optional()
+});
+const instructionGetRulesResponseSchema = zod.z.array(_otim_utils_schemas.instructionSchema);
 
-// src/api/schemas/integration.ts
-var import_zod14 = require("zod");
-var IntegrationType = {
-  Bank: "Bank",
-  Clio: "Clio",
-  Stripe: "Stripe",
-  QuickBooks: "QuickBooks",
-  Bill: "Bill",
-  Zoho: "Zoho"
+//#endregion
+//#region src/api/schemas/integration.ts
+const IntegrationType = {
+	Bank: "Bank",
+	Clio: "Clio",
+	Stripe: "Stripe",
+	QuickBooks: "QuickBooks",
+	Bill: "Bill",
+	Zoho: "Zoho"
 };
-var integrationTypeValues = [
-  IntegrationType.Bank,
-  IntegrationType.Clio,
-  IntegrationType.Stripe,
-  IntegrationType.QuickBooks,
-  IntegrationType.Bill,
-  IntegrationType.Zoho
+const integrationTypeValues = [
+	IntegrationType.Bank,
+	IntegrationType.Clio,
+	IntegrationType.Stripe,
+	IntegrationType.QuickBooks,
+	IntegrationType.Bill,
+	IntegrationType.Zoho
 ];
-var quickBooksDetailsSchema = import_zod14.z.object({
-  accessToken: import_zod14.z.string().optional(),
-  refreshToken: import_zod14.z.string().optional(),
-  realmId: import_zod14.z.string().optional(),
-  tokenType: import_zod14.z.string().optional(),
-  expiresIn: import_zod14.z.number().optional(),
-  xRefreshTokenExpiresIn: import_zod14.z.number().optional()
-});
-var stripeTokensSchema = import_zod14.z.object({
-  accessToken: import_zod14.z.string(),
-  refreshToken: import_zod14.z.string().optional()
-});
-var stripeDetailsSchema = import_zod14.z.object({
-  clientId: import_zod14.z.string().optional(),
-  clientSecret: import_zod14.z.string().optional(),
-  tokens: stripeTokensSchema.optional()
-});
-var billcomDetailsSchema = import_zod14.z.object({
-  devKey: import_zod14.z.string().optional(),
-  sessionId: import_zod14.z.string().optional(),
-  orgId: import_zod14.z.string().optional(),
-  rememberMeId: import_zod14.z.string().optional()
-});
-var liquidationAddressSchema = import_zod14.z.object({
-  liquidationAddressId: import_zod14.z.string(),
-  address: import_zod14.z.string(),
-  chain: import_zod14.z.string(),
-  currency: import_zod14.z.string(),
-  blockchainMemo: import_zod14.z.string().optional()
-});
-var plaidAccountSchema = import_zod14.z.object({
-  accountId: import_zod14.z.string(),
-  name: import_zod14.z.string().optional(),
-  mask: import_zod14.z.string().optional(),
-  subtype: import_zod14.z.string().optional(),
-  externalAccountId: import_zod14.z.string().optional(),
-  liquidationAddress: liquidationAddressSchema.optional()
-});
-var plaidConnectionSchema = import_zod14.z.object({
-  accessToken: import_zod14.z.string(),
-  itemId: import_zod14.z.string(),
-  institutionId: import_zod14.z.string().optional(),
-  institutionName: import_zod14.z.string().optional(),
-  accounts: import_zod14.z.array(plaidAccountSchema)
-});
-var bridgeConnectionSchema = import_zod14.z.object({
-  customerId: import_zod14.z.string(),
-  kycLinkId: import_zod14.z.string().optional(),
-  kycLink: import_zod14.z.string().optional(),
-  tosLink: import_zod14.z.string().optional(),
-  completedSteps: import_zod14.z.array(import_zod14.z.string()).optional()
-});
-var bankDetailsSchema = import_zod14.z.object({
-  plaid: import_zod14.z.array(plaidConnectionSchema).optional(),
-  bridge: import_zod14.z.array(bridgeConnectionSchema).optional()
-});
-var integrationTypeSchema = import_zod14.z.enum(integrationTypeValues);
-var updateIntegrationRequestSchema = import_zod14.z.discriminatedUnion(
-  "integrationType",
-  [
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.QuickBooks),
-      details: quickBooksDetailsSchema
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Bank),
-      details: bankDetailsSchema
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Clio),
-      details: import_zod14.z.unknown()
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Stripe),
-      details: stripeDetailsSchema
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Bill),
-      details: billcomDetailsSchema
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Zoho),
-      details: import_zod14.z.unknown()
-    })
-  ]
-);
-var getIntegrationRequestSchema = import_zod14.z.object({
-  integrationType: integrationTypeSchema
-});
-var integrationResponseSchema = import_zod14.z.discriminatedUnion(
-  "integrationType",
-  [
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.QuickBooks),
-      details: quickBooksDetailsSchema
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Bank),
-      details: bankDetailsSchema
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Clio),
-      details: import_zod14.z.unknown()
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Stripe),
-      details: stripeDetailsSchema
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Bill),
-      details: billcomDetailsSchema
-    }),
-    import_zod14.z.object({
-      integrationType: import_zod14.z.literal(IntegrationType.Zoho),
-      details: import_zod14.z.unknown()
-    })
-  ]
-);
+const quickBooksDetailsSchema = zod.z.object({
+	accessToken: zod.z.string().optional(),
+	refreshToken: zod.z.string().optional(),
+	realmId: zod.z.string().optional(),
+	tokenType: zod.z.string().optional(),
+	expiresIn: zod.z.number().optional(),
+	xRefreshTokenExpiresIn: zod.z.number().optional()
+});
+const stripeTokensSchema = zod.z.object({
+	accessToken: zod.z.string(),
+	refreshToken: zod.z.string().optional()
+});
+const stripeDetailsSchema = zod.z.object({
+	clientId: zod.z.string().optional(),
+	clientSecret: zod.z.string().optional(),
+	tokens: stripeTokensSchema.optional()
+});
+const billcomDetailsSchema = zod.z.object({
+	devKey: zod.z.string().optional(),
+	sessionId: zod.z.string().optional(),
+	orgId: zod.z.string().optional(),
+	rememberMeId: zod.z.string().optional()
+});
+const liquidationAddressSchema = zod.z.object({
+	liquidationAddressId: zod.z.string(),
+	address: zod.z.string(),
+	chain: zod.z.string(),
+	currency: zod.z.string(),
+	blockchainMemo: zod.z.string().optional()
+});
+const plaidAccountSchema = zod.z.object({
+	accountId: zod.z.string(),
+	name: zod.z.string().optional(),
+	mask: zod.z.string().optional(),
+	subtype: zod.z.string().optional(),
+	externalAccountId: zod.z.string().optional(),
+	liquidationAddress: liquidationAddressSchema.optional()
+});
+const plaidConnectionSchema = zod.z.object({
+	accessToken: zod.z.string(),
+	itemId: zod.z.string(),
+	institutionId: zod.z.string().optional(),
+	institutionName: zod.z.string().optional(),
+	accounts: zod.z.array(plaidAccountSchema)
+});
+const bridgeConnectionSchema = zod.z.object({
+	customerId: zod.z.string(),
+	kycLinkId: zod.z.string().optional(),
+	kycLink: zod.z.string().optional(),
+	tosLink: zod.z.string().optional(),
+	completedSteps: zod.z.array(zod.z.string()).optional()
+});
+const bankDetailsSchema = zod.z.object({
+	plaid: zod.z.array(plaidConnectionSchema).optional(),
+	bridge: zod.z.array(bridgeConnectionSchema).optional()
+});
+const integrationTypeSchema = zod.z.enum(integrationTypeValues);
+const updateIntegrationRequestSchema = zod.z.discriminatedUnion("integrationType", [
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.QuickBooks),
+		details: quickBooksDetailsSchema
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Bank),
+		details: bankDetailsSchema
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Clio),
+		details: zod.z.unknown()
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Stripe),
+		details: stripeDetailsSchema
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Bill),
+		details: billcomDetailsSchema
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Zoho),
+		details: zod.z.unknown()
+	})
+]);
+const getIntegrationRequestSchema = zod.z.object({ integrationType: integrationTypeSchema });
+const integrationResponseSchema = zod.z.discriminatedUnion("integrationType", [
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.QuickBooks),
+		details: quickBooksDetailsSchema
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Bank),
+		details: bankDetailsSchema
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Clio),
+		details: zod.z.unknown()
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Stripe),
+		details: stripeDetailsSchema
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Bill),
+		details: billcomDetailsSchema
+	}),
+	zod.z.object({
+		integrationType: zod.z.literal(IntegrationType.Zoho),
+		details: zod.z.unknown()
+	})
+]);
 
-// src/api/schemas/operating-account.ts
-var import_zod15 = require("zod");
-var newOperatingAccountSubOrgResponseSchema = import_zod15.z.object({
-  subOrganizationId: import_zod15.z.string(),
-  endUserId: import_zod15.z.string()
-});
-var getOperatingAccountSubOrgResponseSchema = import_zod15.z.object({
-  subOrganizationId: import_zod15.z.string()
+//#endregion
+//#region src/api/schemas/operating-account.ts
+const newOperatingAccountSubOrgResponseSchema = zod.z.object({
+	subOrganizationId: zod.z.string(),
+	endUserId: zod.z.string()
 });
+const getOperatingAccountSubOrgResponseSchema = zod.z.object({ subOrganizationId: zod.z.string() });
 
-// src/api/schemas/payments.ts
-var import_zod16 = require("zod");
-var paymentRequestsDirectionSchema = import_zod16.z.enum(["from", "to"]);
-var getPaymentRequestsRequestSchema = import_zod16.z.object({
-  direction: paymentRequestsDirectionSchema,
-  statuses: import_zod16.z.array(import_zod16.z.enum(["pending", "inProgress", "paid", "cancelled", "draft"])).optional(),
-  perPage: numberSchema.optional(),
-  page: numberSchema.optional()
-});
-var paymentRequestStatusSchema = import_zod16.z.enum([
-  "pending",
-  "inProgress",
-  "paid",
-  "cancelled",
-  "draft"
+//#endregion
+//#region src/api/schemas/payments.ts
+const paymentRequestsDirectionSchema = zod.z.enum(["from", "to"]);
+const orchestrationTypeSchema = zod.z.enum(["AutoEarn", "PaymentRequest"]);
+const getPaymentRequestsRequestSchema = zod.z.object({
+	direction: paymentRequestsDirectionSchema,
+	statuses: zod.z.array(zod.z.enum([
+		"pending",
+		"inProgress",
+		"paid",
+		"cancelled",
+		"draft"
+	])).optional(),
+	perPage: _otim_utils_schemas.numberSchema.optional(),
+	page: _otim_utils_schemas.numberSchema.optional(),
+	orchestrationType: orchestrationTypeSchema.optional()
+});
+const paymentRequestStatusSchema = zod.z.enum([
+	"pending",
+	"inProgress",
+	"paid",
+	"cancelled",
+	"draft"
 ]);
-var paymentRequestSchema = import_zod16.z.object({
-  id: import_zod16.z.string(),
-  fromUserId: import_zod16.z.string(),
-  toUserId: import_zod16.z.string().nullable(),
-  payerAddress: hexStringSchema.nullable(),
-  ephemeralWalletAddress: hexStringSchema,
-  instructions: import_zod16.z.object({
-    ids: import_zod16.z.array(import_zod16.z.string()),
-    completionIds: import_zod16.z.array(import_zod16.z.string())
-  }),
-  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()),
-  status: paymentRequestStatusSchema,
-  createdAt: import_zod16.z.string(),
-  updatedAt: import_zod16.z.string()
-});
-var getPaymentRequestsResponseSchema = import_zod16.z.array(paymentRequestSchema);
-var buildEphemeralInstructionSchema = import_zod16.z.object({
-  chainId: import_zod16.z.number(),
-  salt: numberSchema,
-  maxExecutions: numberSchema,
-  actionArguments: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()),
-  setEphemeralTarget: import_zod16.z.boolean().optional()
-});
-var paymentRequestBuildRequestSchema = import_zod16.z.object({
-  payerAddress: hexStringSchema.nullish(),
-  completionInstructions: import_zod16.z.array(buildEphemeralInstructionSchema),
-  instructions: import_zod16.z.array(buildEphemeralInstructionSchema),
-  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional().default({}),
-  maxRuns: import_zod16.z.number().int().positive({ message: "maxRuns must be greater than 0" }).max(Number.MAX_SAFE_INTEGER, {
-    message: "maxRuns must be less than MAX_SAFE_INTEGER"
-  }).optional()
-});
-var feeResponseSchema2 = import_zod16.z.object({
-  token: hexStringSchema,
-  executionFee: hexStringSchema,
-  maxBaseFeePerGas: hexStringSchema,
-  maxPriorityFeePerGas: hexStringSchema
-});
-var buildInstructionResponseSchema = import_zod16.z.object({
-  address: hexStringSchema,
-  chainId: import_zod16.z.number(),
-  salt: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  action: hexStringSchema,
-  arguments: hexStringSchema
-});
-var paymentRequestBuildResponseSchema = import_zod16.z.object({
-  requestId: import_zod16.z.string(),
-  subOrgId: import_zod16.z.string(),
-  walletId: import_zod16.z.string(),
-  ephemeralWalletAddress: hexStringSchema,
-  completionInstructions: import_zod16.z.array(buildInstructionResponseSchema),
-  instructions: import_zod16.z.array(buildInstructionResponseSchema)
-});
-var newInstructionRequestSchema = import_zod16.z.object({
-  nickname: import_zod16.z.string().optional(),
-  address: hexStringSchema,
-  chainId: import_zod16.z.number(),
-  salt: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  action: hexStringSchema,
-  arguments: hexStringSchema,
-  activationSignature: eip2098SignatureSchema
-});
-var paymentRequestNewRequestSchema = import_zod16.z.object({
-  requestId: import_zod16.z.string(),
-  signedAuthorization: import_zod16.z.string(),
-  completionInstructions: import_zod16.z.array(newInstructionRequestSchema),
-  instructions: import_zod16.z.array(newInstructionRequestSchema)
-});
-var paymentRequestDetailsRequestSchema = import_zod16.z.object({
-  requestId: import_zod16.z.string()
-});
-var paymentRequestDetailsResponseSchema = import_zod16.z.object({
-  requestId: import_zod16.z.string(),
-  ephemeralWalletAddress: hexStringSchema,
-  ephemeralWalletId: import_zod16.z.string().optional(),
-  status: import_zod16.z.enum(["pending", "inProgress", "paid", "cancelled", "draft"]),
-  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()),
-  numRuns: import_zod16.z.number(),
-  maxRuns: import_zod16.z.number().optional()
-});
-var buildSettlementRequestSchema = import_zod16.z.object({
-  acceptedTokens: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.array(hexStringSchema)),
-  settlementChain: import_zod16.z.number(),
-  settlementToken: hexStringSchema,
-  settlementAmount: numberSchema,
-  recipientAddress: hexStringSchema,
-  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()),
-  payerAddress: hexStringSchema.nullish(),
-  dueDate: import_zod16.z.string().datetime().nullish(),
-  maxRuns: import_zod16.z.number().int().positive().nullish()
-});
-var buildSettlementResponseSchema = import_zod16.z.object({
-  requestId: import_zod16.z.string(),
-  subOrgId: import_zod16.z.string(),
-  walletId: import_zod16.z.string(),
-  ephemeralWalletAddress: hexStringSchema,
-  completionInstructions: import_zod16.z.array(buildInstructionResponseSchema),
-  instructions: import_zod16.z.array(buildInstructionResponseSchema)
+const paymentRequestSchema = zod.z.object({
+	id: zod.z.string(),
+	fromUserId: zod.z.string(),
+	toUserId: zod.z.string().nullable(),
+	payerAddress: _otim_utils_schemas.hexStringSchema.nullable(),
+	ephemeralWalletAddress: _otim_utils_schemas.hexStringSchema,
+	instructions: zod.z.object({
+		ids: zod.z.array(zod.z.string()),
+		completionIds: zod.z.array(zod.z.string())
+	}),
+	metadata: zod.z.record(zod.z.string(), zod.z.unknown()),
+	status: paymentRequestStatusSchema,
+	createdAt: zod.z.string(),
+	updatedAt: zod.z.string()
+});
+const getPaymentRequestsResponseSchema = zod.z.array(paymentRequestSchema);
+const buildEphemeralInstructionSchema = zod.z.object({
+	chainId: zod.z.number(),
+	salt: _otim_utils_schemas.numberSchema,
+	maxExecutions: _otim_utils_schemas.numberSchema,
+	actionArguments: zod.z.record(zod.z.string(), zod.z.unknown()),
+	setEphemeralTarget: zod.z.boolean().optional()
+});
+const paymentRequestBuildRequestSchema = zod.z.object({
+	payerAddress: _otim_utils_schemas.hexStringSchema.nullish(),
+	completionInstructions: zod.z.array(buildEphemeralInstructionSchema),
+	instructions: zod.z.array(buildEphemeralInstructionSchema),
+	metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional().default({}),
+	maxRuns: zod.z.number().int().positive({ message: "maxRuns must be greater than 0" }).max(Number.MAX_SAFE_INTEGER, { message: "maxRuns must be less than MAX_SAFE_INTEGER" }).optional()
+});
+const feeResponseSchema = zod.z.object({
+	token: _otim_utils_schemas.hexStringSchema,
+	executionFee: _otim_utils_schemas.hexStringSchema,
+	maxBaseFeePerGas: _otim_utils_schemas.hexStringSchema,
+	maxPriorityFeePerGas: _otim_utils_schemas.hexStringSchema
+});
+const buildInstructionResponseSchema = zod.z.object({
+	address: _otim_utils_schemas.hexStringSchema,
+	chainId: zod.z.number(),
+	salt: _otim_utils_schemas.hexStringSchema,
+	maxExecutions: _otim_utils_schemas.hexStringSchema,
+	action: _otim_utils_schemas.hexStringSchema,
+	actionName: zod.z.string().optional(),
+	arguments: _otim_utils_schemas.hexStringSchema
+});
+const paymentRequestBuildResponseSchema = zod.z.object({
+	requestId: zod.z.string(),
+	subOrgId: zod.z.string(),
+	walletId: zod.z.string(),
+	ephemeralWalletAddress: _otim_utils_schemas.hexStringSchema,
+	completionInstructions: zod.z.array(buildInstructionResponseSchema),
+	instructions: zod.z.array(buildInstructionResponseSchema)
+});
+const newInstructionRequestSchema = zod.z.object({
+	nickname: zod.z.string().optional(),
+	actionName: zod.z.string().optional(),
+	address: _otim_utils_schemas.hexStringSchema,
+	chainId: zod.z.number(),
+	salt: _otim_utils_schemas.hexStringSchema,
+	maxExecutions: _otim_utils_schemas.hexStringSchema,
+	action: _otim_utils_schemas.hexStringSchema,
+	arguments: _otim_utils_schemas.hexStringSchema,
+	activationSignature: _otim_utils_schemas.eip2098SignatureSchema
+});
+const paymentRequestNewRequestSchema = zod.z.object({
+	requestId: zod.z.string(),
+	signedAuthorization: zod.z.string(),
+	completionInstructions: zod.z.array(newInstructionRequestSchema),
+	instructions: zod.z.array(newInstructionRequestSchema)
+});
+const paymentRequestDetailsRequestSchema = zod.z.object({ requestId: zod.z.string() });
+const paymentRequestDetailsResponseSchema = zod.z.object({
+	requestId: zod.z.string(),
+	ephemeralWalletAddress: _otim_utils_schemas.hexStringSchema,
+	ephemeralWalletId: zod.z.string().optional(),
+	status: zod.z.enum([
+		"pending",
+		"inProgress",
+		"paid",
+		"cancelled",
+		"draft"
+	]),
+	metadata: zod.z.record(zod.z.string(), zod.z.unknown()),
+	numRuns: zod.z.number(),
+	maxRuns: zod.z.number().optional()
+});
+const buildSettlementRequestSchema = zod.z.object({
+	acceptedTokens: zod.z.record(zod.z.string(), zod.z.array(_otim_utils_schemas.hexStringSchema)),
+	settlementChain: zod.z.number(),
+	settlementToken: _otim_utils_schemas.hexStringSchema,
+	settlementAmount: _otim_utils_schemas.numberSchema,
+	recipientAddress: _otim_utils_schemas.hexStringSchema,
+	metadata: zod.z.record(zod.z.string(), zod.z.unknown()),
+	payerAddress: _otim_utils_schemas.hexStringSchema.nullish(),
+	dueDate: zod.z.string().datetime().nullish(),
+	maxRuns: zod.z.number().int().positive().nullish()
+});
+const buildSettlementResponseSchema = zod.z.object({
+	requestId: zod.z.string(),
+	subOrgId: zod.z.string(),
+	walletId: zod.z.string(),
+	ephemeralWalletAddress: _otim_utils_schemas.hexStringSchema,
+	completionInstructions: zod.z.array(buildInstructionResponseSchema),
+	instructions: zod.z.array(buildInstructionResponseSchema)
 });
 
-// src/api/schemas/transaction.ts
-var import_zod17 = require("zod");
-var transactionGetListRequestSchema = import_zod17.z.object({
-  address: hexStringSchema,
-  chainId: import_zod17.z.number(),
-  instructionIds: import_zod17.z.array(import_zod17.z.string()).optional(),
-  from: import_zod17.z.string().optional(),
-  to: import_zod17.z.string().optional(),
-  page: import_zod17.z.number().optional(),
-  perPage: import_zod17.z.number().optional(),
-  sort: import_zod17.z.enum(sortValues).optional()
-});
-var transactionGetListResponseSchema = import_zod17.z.array(transactionSchema);
+//#endregion
+//#region src/api/schemas/transaction.ts
+const transactionGetListRequestSchema = zod.z.object({
+	address: _otim_utils_schemas.hexStringSchema,
+	chainId: zod.z.number(),
+	instructionIds: zod.z.array(zod.z.string()).optional(),
+	from: zod.z.string().optional(),
+	to: zod.z.string().optional(),
+	page: zod.z.number().optional(),
+	perPage: zod.z.number().optional(),
+	sort: zod.z.enum(_otim_utils_schemas.sortValues).optional()
+});
+const transactionGetListResponseSchema = zod.z.array(_otim_utils_schemas.transactionSchema);
 
-// src/env.ts
-var BUILD_MODE = "development";
-
-// src/helpers/logger.ts
-var Logger = class {
-  constructor() {
-    __publicField(this, "isDevelopment", BUILD_MODE === "development");
-  }
-  debug(message, options) {
-    if (this.isDevelopment) {
-      this.log("debug", message, options);
-    }
-  }
-  info(message, options) {
-    this.log("info", message, options);
-  }
-  warn(message, options) {
-    this.log("warn", message, options);
-  }
-  error(message, options) {
-    this.log("error", message, options);
-  }
-  /**
-   * Log errors with context - useful for non-API errors
-   * For API errors, use the existing getErrorMessage from @otim/utils/api
-   */
-  logError(error, options = {}) {
-    const { context, operation, metadata } = options;
-    const prefix = this.buildPrefix(context, operation);
-    let message = "Unknown error";
-    if (error instanceof Error) {
-      message = error.message;
-    } else if (typeof error === "string") {
-      message = error;
-    } else if (error && typeof error === "object" && "message" in error) {
-      message = String(error.message);
-    }
-    console.error(prefix ? `${prefix} ${message}` : message);
-    if (metadata && Object.keys(metadata).length > 0) {
-      console.error("Context:", metadata);
-    }
-    if (error instanceof Error && error.stack) {
-      console.error("Stack:", error.stack);
-    } else {
-      console.error("Error details:", error);
-    }
-  }
-  buildPrefix(context, operation) {
-    const parts = [];
-    if (context) parts.push(`[${context}]`);
-    if (operation) parts.push(`[${operation}]`);
-    return parts.join(" ");
-  }
-  log(level, message, options) {
-    const prefix = options?.context ? `[${options.context}]` : "";
-    const fullMessage = `${prefix} ${message}`.trim();
-    switch (level) {
-      case "debug":
-      case "info":
-        console.log(fullMessage);
-        break;
-      case "warn":
-        console.warn(fullMessage);
-        break;
-      case "error":
-        console.error(fullMessage);
-        break;
-    }
-    if (options?.data) {
-      console.dir(options.data, { depth: null });
-    }
-  }
-};
-var logger = new Logger();
-
-// src/helpers/zod.ts
-var import_zod18 = require("zod");
-var parseSchema = (values, schema) => {
-  const inputValues = schema.safeParse(values);
-  if (!inputValues.success) {
-    throw new Error(
-      `parseSchema: invalid input values ${JSON.stringify(inputValues.error)}`
-    );
-  }
-  return inputValues.data;
+//#endregion
+//#region src/api/utils/backoff.ts
+const DEFAULT_INITIAL_INTERVAL = 5e3;
+const DEFAULT_MAX_INTERVAL = 3e4;
+const DEFAULT_MULTIPLIER = 1.5;
+/**
+* Calculates an exponential backoff interval based on the failure count.
+*
+* @param failureCount - Number of consecutive failures
+* @param options - Configuration options for the backoff calculation
+* @returns The calculated interval in milliseconds, capped at maxInterval
+*/
+const calculateBackoffInterval = (failureCount, options = {}) => {
+	const { initialInterval = DEFAULT_INITIAL_INTERVAL, maxInterval = DEFAULT_MAX_INTERVAL, multiplier = DEFAULT_MULTIPLIER } = options;
+	return Math.min(initialInterval * Math.pow(multiplier, failureCount), maxInterval);
 };
 
-// src/api/utils/pagination.ts
+//#endregion
+//#region src/api/utils/pagination.ts
+/**
+* Determine if additional pages are likely available based on the number of
+* items received and the requested page size.
+*
+* Returns true when the current page contains at least `requestedPageSize`
+* items, implying there may be more data to fetch.
+*
+* @param items Array of items returned for the current page.
+* @param requestedPageSize The `perPage` value requested for this fetch.
+* @returns Whether another page may be available.
+*/
 function calculateHasMore(items, requestedPageSize) {
-  return items.length >= requestedPageSize;
+	return items.length >= requestedPageSize;
 }
+/**
+* Extract pagination-related fields from a request object and return them
+* separately from the remaining parameters.
+*
+* @param request Request object containing `page`, `perPage`, and other fields.
+* @returns Object with `paginationParams` and `restParams` split for
+* convenience.
+*/
 function extractPaginationParams(request) {
-  const { page, perPage, ...restParams } = request;
-  return {
-    paginationParams: { page, perPage },
-    restParams
-  };
+	const { page, perPage, ...restParams } = request;
+	return {
+		paginationParams: {
+			page,
+			perPage
+		},
+		restParams
+	};
 }
+/**
+* Provide a standard default for pagination parameters.
+*
+* @returns Default pagination with `page: 0` and `perPage: 100`.
+*/
 function getDefaultPagination() {
-  return {
-    page: 0,
-    perPage: 100
-  };
+	return {
+		page: 0,
+		perPage: 100
+	};
 }
 
-// src/api/services/base.ts
+//#endregion
+//#region src/api/services/base.ts
 var BaseService = class {
-  constructor(instance) {
-    this.instance = instance;
-  }
-  async makeRequest({
-    url,
-    method = HttpMethod.Get,
-    data,
-    schema,
-    validateResponse,
-    ...config
-  }) {
-    try {
-      const res = await this.instance.request({ url, method, data, ...config });
-      if (validateResponse && !validateResponse(res.data)) {
-        throw new ServiceError("Invalid response format", "INVALID_RESPONSE");
-      }
-      const parsedData = schema ? parseSchema(res.data, schema) : res.data;
-      return { data: parsedData };
-    } catch (error) {
-      if (error instanceof ServiceError) {
-        throw error;
-      }
-      let errorMessage = "Unknown error";
-      let errorCode;
-      if (error && typeof error === "object" && "response" in error) {
-        const axiosError = error;
-        const responseData = axiosError.response?.data;
-        errorMessage = responseData?.errorMessage || responseData?.message || errorMessage;
-        errorCode = responseData?.errorCode;
-      } else if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      throw new ServiceError(errorMessage, errorCode || "REQUEST_FAILED");
-    }
-  }
-  async makePaginatedRequest({
-    url,
-    method = HttpMethod.Get,
-    data,
-    schema,
-    validateResponse,
-    ...config
-  }) {
-    const { paginationParams, restParams } = extractPaginationParams(
-      data || {}
-    );
-    const { page, perPage } = {
-      ...getDefaultPagination(),
-      ...paginationParams
-    };
-    const requestData = { ...restParams, page, perPage };
-    const response = await this.makeRequest({
-      url,
-      method,
-      data: requestData,
-      schema,
-      validateResponse,
-      ...config
-    });
-    const hasMore = Array.isArray(response.data) ? calculateHasMore(response.data, perPage) : false;
-    return {
-      data: response.data,
-      hasMore
-    };
-  }
+	constructor(instance) {
+		this.instance = instance;
+	}
+	async makeRequest({ url, method = HttpMethod.Get, data, schema, validateResponse, ...config }) {
+		try {
+			const res = await this.instance.request({
+				url,
+				method,
+				data,
+				...config
+			});
+			if (validateResponse && !validateResponse(res.data)) throw new ServiceError("Invalid response format", "INVALID_RESPONSE");
+			return { data: schema ? (0, _otim_utils_helpers.parseSchema)(res.data, schema) : res.data };
+		} catch (error) {
+			if (error instanceof ServiceError) throw error;
+			let errorMessage = "Unknown error";
+			let errorCode;
+			if (error && typeof error === "object" && "response" in error) {
+				const responseData = error.response?.data;
+				errorMessage = responseData?.errorMessage || responseData?.message || errorMessage;
+				errorCode = responseData?.errorCode;
+			} else if (error instanceof Error) errorMessage = error.message;
+			throw new ServiceError(errorMessage, errorCode || "REQUEST_FAILED");
+		}
+	}
+	async makePaginatedRequest({ url, method = HttpMethod.Get, data, schema, validateResponse, ...config }) {
+		const { paginationParams, restParams } = extractPaginationParams(data || {});
+		const { page, perPage } = {
+			...getDefaultPagination(),
+			...paginationParams
+		};
+		const requestData = {
+			...restParams,
+			page,
+			perPage
+		};
+		const response = await this.makeRequest({
+			url,
+			method,
+			data: requestData,
+			schema,
+			validateResponse,
+			...config
+		});
+		const hasMore = Array.isArray(response.data) ? calculateHasMore(response.data, perPage) : false;
+		return {
+			data: response.data,
+			hasMore
+		};
+	}
 };
 
-// src/api/services/account.ts
+//#endregion
+//#region src/api/services/account.ts
 var AccountService = class extends BaseService {
-  async getDelegationStatus(requestBody) {
-    const res = await this.makeRequest({
-      url: "/delegation/status",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: delegationStatusResponseSchema
-    });
-    return res;
-  }
-  async createDelegation(requestBody) {
-    await this.makeRequest({
-      url: "/delegation/new",
-      method: HttpMethod.Post,
-      data: requestBody
-    });
-    return {
-      data: { success: true, message: "Delegation created" }
-    };
-  }
+	async getDelegationStatus(requestBody) {
+		return await this.makeRequest({
+			url: "/delegation/status",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: delegationStatusResponseSchema
+		});
+	}
+	async createDelegation(requestBody) {
+		await this.makeRequest({
+			url: "/delegation/new",
+			method: HttpMethod.Post,
+			data: requestBody
+		});
+		return { data: {
+			success: true,
+			message: "Delegation created"
+		} };
+	}
 };
 
-// src/api/services/activity.ts
-var import_zod19 = require("zod");
-var safeParseActivityArray = (data) => {
-  if (!Array.isArray(data)) {
-    return [];
-  }
-  const validRecords = [];
-  data.forEach((record) => {
-    const result = activityRecordSchema.safeParse(record);
-    if (result.success) {
-      validRecords.push(result.data);
-    }
-  });
-  return validRecords;
+//#endregion
+//#region src/api/services/activity.ts
+const safeParseActivityArray = (data) => {
+	if (!Array.isArray(data)) return [];
+	const validRecords = [];
+	data.forEach((record) => {
+		const result = activityRecordSchema.safeParse(record);
+		if (result.success) validRecords.push(result.data);
+	});
+	return validRecords;
 };
-var safeActivityArraySchema = import_zod19.z.unknown().transform(safeParseActivityArray);
+const safeActivityArraySchema = zod.z.unknown().transform(safeParseActivityArray);
 var ActivityService = class extends BaseService {
-  async getInstructionActivity(requestBody) {
-    return this.makePaginatedRequest({
-      url: "/instructions/activity",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: safeActivityArraySchema
-    });
-  }
+	async getInstructionActivity(requestBody) {
+		return this.makePaginatedRequest({
+			url: "/instructions/activity",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: safeActivityArraySchema
+		});
+	}
 };
 
-// src/api/services/auth.ts
+//#endregion
+//#region src/api/services/auth.ts
 var AuthService = class extends BaseService {
-  async login(requestBody) {
-    const res = await this.makeRequest({
-      url: "/auth/login",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: authLoginResponseSchema
-    });
-    return res;
-  }
-  async turnkeyVerification(requestBody) {
-    const res = await this.makeRequest({
-      url: "/turnkey/verification",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: turnkeyVerificationResponseSchema
-    });
-    return res;
-  }
-  async turnkeyLogin(requestBody) {
-    const res = await this.makeRequest({
-      url: "/turnkey/login",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: turnkeyLoginResponseSchema
-    });
-    return res;
-  }
-  async me() {
-    const res = await this.makeRequest({
-      url: "/auth/me",
-      method: HttpMethod.Get,
-      schema: userSchema
-    });
-    return res;
-  }
-  async updatePreferences(preferences) {
-    const res = await this.makeRequest({
-      url: "/user/preferences",
-      method: HttpMethod.Put,
-      data: { preferences }
-    });
-    return res;
-  }
+	async login(requestBody) {
+		return await this.makeRequest({
+			url: "/auth/login",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: authLoginResponseSchema
+		});
+	}
+	async turnkeyVerification(requestBody) {
+		return await this.makeRequest({
+			url: "/turnkey/verification",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: turnkeyVerificationResponseSchema
+		});
+	}
+	async turnkeyLogin(requestBody) {
+		return await this.makeRequest({
+			url: "/turnkey/login",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: turnkeyLoginResponseSchema
+		});
+	}
+	async me() {
+		return await this.makeRequest({
+			url: "/auth/me",
+			method: HttpMethod.Get,
+			schema: _otim_utils_schemas.userSchema
+		});
+	}
+	async updatePreferences(preferences) {
+		return await this.makeRequest({
+			url: "/user/preferences",
+			method: HttpMethod.Put,
+			data: { preferences }
+		});
+	}
 };
 
-// src/api/services/config.ts
+//#endregion
+//#region src/api/services/config.ts
 var ConfigService = class extends BaseService {
-  async getDelegateAddress(requestBody) {
-    const res = await this.makeRequest({
-      url: `/config/delegate/address/${requestBody.chainId}`,
-      method: HttpMethod.Get,
-      schema: getDelegateAddressResponseSchema
-    });
-    return res;
-  }
-  async getConfigTokens({
-    chainId
-  }) {
-    const res = await this.makeRequest({
-      url: `/config/tokens/${chainId}`,
-      method: HttpMethod.Get,
-      schema: getConfigTokensResponseSchema
-    });
-    return res;
-  }
-  async getConfigChains() {
-    const res = await this.makeRequest({
-      url: `/config/chains`,
-      method: HttpMethod.Get,
-      schema: getConfigChainsResponseSchema
-    });
-    return res;
-  }
-  async getMaxPriorityFeePerGasEstimate(requestBody) {
-    const res = await this.makeRequest({
-      url: `/instruction/estimate/max_priority_fee_per_gas/${requestBody.chainId}`,
-      method: HttpMethod.Get,
-      schema: getMaxPriorityFeePerGasEstimateResponseSchema
-    });
-    return res;
-  }
+	async getDelegateAddress(requestBody) {
+		return await this.makeRequest({
+			url: `/config/delegate/address/${requestBody.chainId}`,
+			method: HttpMethod.Get,
+			schema: getDelegateAddressResponseSchema
+		});
+	}
+	async getConfigTokens({ chainId }) {
+		return await this.makeRequest({
+			url: `/config/tokens/${chainId}`,
+			method: HttpMethod.Get,
+			schema: getConfigTokensResponseSchema
+		});
+	}
+	async getConfigChains() {
+		return await this.makeRequest({
+			url: `/config/chains`,
+			method: HttpMethod.Get,
+			schema: getConfigChainsResponseSchema
+		});
+	}
+	async getMaxPriorityFeePerGasEstimate(requestBody) {
+		return await this.makeRequest({
+			url: `/instruction/estimate/max_priority_fee_per_gas/${requestBody.chainId}`,
+			method: HttpMethod.Get,
+			schema: getMaxPriorityFeePerGasEstimateResponseSchema
+		});
+	}
 };
 
-// src/api/services/contacts.ts
+//#endregion
+//#region src/api/services/contacts.ts
 var ContactsService = class extends BaseService {
-  async create(request) {
-    const validated = newContactRequestSchema.parse(request);
-    return this.makeRequest({
-      url: "/contacts",
-      method: HttpMethod.Put,
-      data: validated
-    });
-  }
-  async list(request) {
-    const validated = getContactsRequestSchema.parse(request);
-    return this.makePaginatedRequest({
-      url: "/contacts",
-      method: HttpMethod.Get,
-      data: validated,
-      schema: getContactsResponseSchema
-    });
-  }
+	async create(request) {
+		const validated = newContactRequestSchema.parse(request);
+		return this.makeRequest({
+			url: "/contacts",
+			method: HttpMethod.Put,
+			data: validated
+		});
+	}
+	async list(request) {
+		const validated = getContactsRequestSchema.parse(request);
+		return this.makePaginatedRequest({
+			url: "/contacts",
+			method: HttpMethod.Get,
+			data: validated,
+			schema: getContactsResponseSchema
+		});
+	}
 };
 
-// src/api/services/developer.ts
+//#endregion
+//#region src/api/services/developer.ts
 var DeveloperService = class extends BaseService {
-  async updatePublicKey(developerPublicKey) {
-    return this.makeRequest({
-      url: "/developer/public_key",
-      method: HttpMethod.Put,
-      data: { developerPublicKey }
-    });
-  }
-  async generateApiKey() {
-    return this.makeRequest({
-      url: "/developer/api_key",
-      method: HttpMethod.Post
-    });
-  }
+	async updatePublicKey(developerPublicKey) {
+		return this.makeRequest({
+			url: "/developer/public_key",
+			method: HttpMethod.Put,
+			data: { developerPublicKey }
+		});
+	}
+	async generateApiKey() {
+		return this.makeRequest({
+			url: "/developer/api_key",
+			method: HttpMethod.Post
+		});
+	}
 };
 
-// src/api/services/instruction.ts
+//#endregion
+//#region src/api/services/instruction.ts
 var InstructionService = class extends BaseService {
-  async all(requestBody) {
-    return this.makePaginatedRequest({
-      url: "/instructions/all",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: instructionsSchema
-    });
-  }
-  async build(requestBody) {
-    const res = await this.makeRequest({
-      url: "/instruction/build",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: instructionBuildSchema
-    });
-    return res;
-  }
-  async activate(requestBody) {
-    const res = await this.makeRequest({
-      url: "/instruction/new",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: instructionActivateResponseSchema
-    });
-    return res;
-  }
-  async deactivate(requestBody) {
-    const res = await this.makeRequest({
-      url: "/instruction/deactivate",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: instructionDeactivateResponseSchema
-    });
-    return res;
-  }
-  async details(requestBody) {
-    const res = await this.makeRequest({
-      url: "/instruction/details",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: instructionDetailsResponseSchema
-    });
-    return res;
-  }
-  async rules(requestBody) {
-    return this.makePaginatedRequest({
-      url: "/instructions/rules",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: instructionGetRulesResponseSchema
-    });
-  }
+	async all(requestBody) {
+		return this.makePaginatedRequest({
+			url: "/instructions/all",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: _otim_utils_schemas.instructionsSchema
+		});
+	}
+	async build(requestBody) {
+		return await this.makeRequest({
+			url: "/instruction/build",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: instructionBuildSchema
+		});
+	}
+	async activate(requestBody) {
+		return await this.makeRequest({
+			url: "/instruction/new",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: instructionActivateResponseSchema
+		});
+	}
+	async deactivate(requestBody) {
+		return await this.makeRequest({
+			url: "/instruction/deactivate",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: instructionDeactivateResponseSchema
+		});
+	}
+	async details(requestBody) {
+		return await this.makeRequest({
+			url: "/instruction/details",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: instructionDetailsResponseSchema
+		});
+	}
+	async rules(requestBody) {
+		return this.makePaginatedRequest({
+			url: "/instructions/rules",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: instructionGetRulesResponseSchema
+		});
+	}
 };
 
-// src/api/services/transaction.ts
+//#endregion
+//#region src/api/services/transaction.ts
 var TransactionService = class extends BaseService {
-  async list(requestBody) {
-    return this.makePaginatedRequest({
-      url: "/transactions",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: transactionGetListResponseSchema
-    });
-  }
+	async list(requestBody) {
+		return this.makePaginatedRequest({
+			url: "/transactions",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: transactionGetListResponseSchema
+		});
+	}
 };
 
-// src/api/services/payments.ts
+//#endregion
+//#region src/api/services/payments.ts
 var PaymentsService = class extends BaseService {
-  async getOutgoingPaymentsList(request) {
-    return this.makePaginatedRequest({
-      url: "/api/payments/outgoing",
-      method: HttpMethod.Get,
-      data: request,
-      schema: PaymentsSchema
-    });
-  }
-  async getIncomingPaymentsList(request) {
-    return this.makePaginatedRequest({
-      url: "/api/payments/incoming",
-      method: HttpMethod.Get,
-      data: request,
-      schema: PaymentsSchema
-    });
-  }
-  async buildPaymentRequest(requestBody) {
-    return this.makeRequest({
-      url: "/orchestration/build",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: paymentRequestBuildResponseSchema
-    });
-  }
-  async newPaymentRequest(requestBody) {
-    return this.makeRequest({
-      url: "/orchestration/new",
-      method: HttpMethod.Post,
-      data: requestBody,
-      validateResponse: () => true
-    });
-  }
-  async getPaymentRequestDetails(requestBody) {
-    return this.makeRequest({
-      url: "/orchestration/details",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: paymentRequestDetailsResponseSchema
-    });
-  }
-  async getPaymentRequests(request) {
-    return this.makePaginatedRequest({
-      url: "/orchestrations",
-      method: HttpMethod.Get,
-      data: request,
-      schema: getPaymentRequestsResponseSchema
-    });
-  }
-  async buildSettlementOrchestration(requestBody) {
-    return this.makeRequest({
-      url: "/orchestration/build/settlement",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: buildSettlementResponseSchema
-    });
-  }
+	async getOutgoingPaymentsList(request) {
+		return this.makePaginatedRequest({
+			url: "/api/payments/outgoing",
+			method: HttpMethod.Get,
+			data: request,
+			schema: _otim_utils_schemas.PaymentsSchema
+		});
+	}
+	async getIncomingPaymentsList(request) {
+		return this.makePaginatedRequest({
+			url: "/api/payments/incoming",
+			method: HttpMethod.Get,
+			data: request,
+			schema: _otim_utils_schemas.PaymentsSchema
+		});
+	}
+	async buildPaymentRequest(requestBody) {
+		return this.makeRequest({
+			url: "/orchestration/build",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: paymentRequestBuildResponseSchema
+		});
+	}
+	async newPaymentRequest(requestBody) {
+		return this.makeRequest({
+			url: "/orchestration/new",
+			method: HttpMethod.Post,
+			data: requestBody,
+			validateResponse: () => true
+		});
+	}
+	async getPaymentRequestDetails(requestBody) {
+		return this.makeRequest({
+			url: "/orchestration/details",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: paymentRequestDetailsResponseSchema
+		});
+	}
+	async getPaymentRequests(request) {
+		return this.makePaginatedRequest({
+			url: "/orchestrations",
+			method: HttpMethod.Get,
+			data: request,
+			schema: getPaymentRequestsResponseSchema
+		});
+	}
+	async buildSettlementOrchestration(requestBody) {
+		return this.makeRequest({
+			url: "/orchestration/build/settlement",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: buildSettlementResponseSchema
+		});
+	}
 };
 
-// src/api/services/integration.ts
-var import_axios2 = __toESM(require("axios"));
+//#endregion
+//#region src/api/services/integration.ts
 function createEmptyIntegrationResponse(integrationType) {
-  switch (integrationType) {
-    case IntegrationType.QuickBooks:
-      return { integrationType: IntegrationType.QuickBooks, details: {} };
-    case IntegrationType.Bank:
-      return { integrationType: IntegrationType.Bank, details: {} };
-    case IntegrationType.Clio:
-      return { integrationType: IntegrationType.Clio, details: {} };
-    case IntegrationType.Stripe:
-      return { integrationType: IntegrationType.Stripe, details: {} };
-    case IntegrationType.Bill:
-      return { integrationType: IntegrationType.Bill, details: {} };
-    case IntegrationType.Zoho:
-      return { integrationType: IntegrationType.Zoho, details: {} };
-    default:
-      return { integrationType: IntegrationType.Bank, details: {} };
-  }
+	switch (integrationType) {
+		case IntegrationType.QuickBooks: return {
+			integrationType: IntegrationType.QuickBooks,
+			details: {}
+		};
+		case IntegrationType.Bank: return {
+			integrationType: IntegrationType.Bank,
+			details: {}
+		};
+		case IntegrationType.Clio: return {
+			integrationType: IntegrationType.Clio,
+			details: {}
+		};
+		case IntegrationType.Stripe: return {
+			integrationType: IntegrationType.Stripe,
+			details: {}
+		};
+		case IntegrationType.Bill: return {
+			integrationType: IntegrationType.Bill,
+			details: {}
+		};
+		case IntegrationType.Zoho: return {
+			integrationType: IntegrationType.Zoho,
+			details: {}
+		};
+		default: return {
+			integrationType: IntegrationType.Bank,
+			details: {}
+		};
+	}
 }
 var IntegrationService = class extends BaseService {
-  async upsert(request) {
-    return this.makeRequest({
-      url: "/integration",
-      method: HttpMethod.Put,
-      data: request,
-      schema: integrationResponseSchema
-    });
-  }
-  async get(request) {
-    try {
-      return await this.makeRequest(
-        {
-          url: "/integration/get",
-          method: HttpMethod.Post,
-          data: request,
-          schema: integrationResponseSchema
-        }
-      );
-    } catch (error) {
-      if (import_axios2.default.isAxiosError(error) && error.response?.status === 404) {
-        const defaultResponse = createEmptyIntegrationResponse(
-          request.integrationType
-        );
-        return { data: defaultResponse };
-      }
-      throw error;
-    }
-  }
+	async upsert(request) {
+		return this.makeRequest({
+			url: "/integration",
+			method: HttpMethod.Put,
+			data: request,
+			schema: integrationResponseSchema
+		});
+	}
+	async get(request) {
+		try {
+			return await this.makeRequest({
+				url: "/integration/get",
+				method: HttpMethod.Post,
+				data: request,
+				schema: integrationResponseSchema
+			});
+		} catch (error) {
+			if (axios.default.isAxiosError(error) && error.response?.status === 404) return { data: createEmptyIntegrationResponse(request.integrationType) };
+			throw error;
+		}
+	}
 };
 
-// src/api/services/operating-account.ts
+//#endregion
+//#region src/api/services/operating-account.ts
 var OperatingAccountService = class extends BaseService {
-  async createSubOrganization() {
-    const res = await this.makeRequest({
-      url: "/operating_accounts/sub_organization/new",
-      method: HttpMethod.Post,
-      schema: newOperatingAccountSubOrgResponseSchema
-    });
-    return res;
-  }
-  async getSubOrganization() {
-    const res = await this.makeRequest({
-      url: "/operating_accounts/sub_organization",
-      method: HttpMethod.Get,
-      schema: getOperatingAccountSubOrgResponseSchema
-    });
-    return res;
-  }
-};
-
-// src/api/services/uniswap-token-list-service.ts
-var UniswapTokenListService = class extends BaseService {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "UNISWAP_TOKEN_LIST_URL", "https://ipfs.io/ipns/tokens.uniswap.org");
-    __publicField(this, "FALLBACK_URL", "https://tokens.uniswap.org/");
-    __publicField(this, "CACHE_DURATION", 30 * 60 * 1e3);
-    // 30 minutes
-    __publicField(this, "SUPPORTED_CHAIN_IDS", [1, 10, 42161, 8453]);
-    // mainnet, optimism, arbitrum, base
-    __publicField(this, "tokenListCache", null);
-    __publicField(this, "lastFetch", 0);
-  }
-  /**
-   * Get tokens for a specific chain
-   */
-  async getTokensForChain({
-    chainId,
-    limit = 50
-  }) {
-    try {
-      const tokenList = await this.fetchTokenList();
-      if (!this.SUPPORTED_CHAIN_IDS.includes(chainId)) {
-        return {
-          data: {
-            tokens: [],
-            source: "uniswap",
-            timestamp: tokenList.timestamp
-          }
-        };
-      }
-      const chainTokens = tokenList.tokens.filter(
-        (token) => token.chainId === chainId
-      );
-      const filteredTokens = chainTokens.filter((token) => {
-        const suspiciousPatterns = [
-          /test/i,
-          /fake/i,
-          /scam/i,
-          /shit/i,
-          /moon/i,
-          /doge/i,
-          /inu/i,
-          /baby/i,
-          /mini/i,
-          /micro/i,
-          /nano/i,
-          /pico/i,
-          /mega/i,
-          /ultra/i,
-          /super/i,
-          /hyper/i,
-          /meta/i,
-          /safe/i,
-          /new/i,
-          /old/i,
-          /v2/i,
-          /v3/i,
-          /v4/i,
-          /v5/i,
-          /2\.0/i,
-          /3\.0/i,
-          /4\.0/i,
-          /5\.0/i
-        ];
-        const name = token.name?.toLowerCase() || "";
-        const symbol = token.symbol?.toLowerCase() || "";
-        if (suspiciousPatterns.some(
-          (pattern) => pattern.test(name) || pattern.test(symbol)
-        )) {
-          return false;
-        }
-        if (name.length < 2 || name.length > 50) return false;
-        if (symbol.length < 2 || symbol.length > 20) return false;
-        if (!token.name || !token.symbol || !token.address) return false;
-        return true;
-      });
-      const limitedTokens = filteredTokens.slice(0, limit);
-      return {
-        data: {
-          tokens: limitedTokens,
-          source: "uniswap",
-          timestamp: tokenList.timestamp
-        }
-      };
-    } catch (error) {
-      throw new Error(error instanceof Error ? error.message : "Unknown error");
-    }
-  }
-  /**
-   * Get all supported chains from the token list
-   */
-  async getSupportedChains() {
-    try {
-      const tokenList = await this.fetchTokenList();
-      const chainIds = Array.from(
-        new Set(tokenList.tokens.map((token) => token.chainId))
-      ).sort((a, b) => a - b);
-      return {
-        data: chainIds
-      };
-    } catch (error) {
-      throw new Error(error instanceof Error ? error.message : "Unknown error");
-    }
-  }
-  /**
-   * Search for a specific token by address or symbol
-   */
-  async findToken(chainId, query) {
-    try {
-      const tokenList = await this.fetchTokenList();
-      const token = tokenList.tokens.find(
-        (t) => t.chainId === chainId && (t.address.toLowerCase() === query.toLowerCase() || t.symbol.toLowerCase() === query.toLowerCase() || t.name.toLowerCase().includes(query.toLowerCase()))
-      );
-      return {
-        data: token || null
-      };
-    } catch (error) {
-      throw new Error(error instanceof Error ? error.message : "Unknown error");
-    }
-  }
-  /**
-   * Get bridge information for a token
-   */
-  async getBridgeInfo(chainId, tokenAddress) {
-    try {
-      const tokenList = await this.fetchTokenList();
-      const token = tokenList.tokens.find(
-        (t) => t.chainId === chainId && t.address.toLowerCase() === tokenAddress.toLowerCase()
-      );
-      if (!token || !token.extensions?.bridgeInfo) {
-        return {
-          data: {}
-        };
-      }
-      const bridgeInfo = {};
-      for (const [targetChainId, info] of Object.entries(
-        token.extensions.bridgeInfo
-      )) {
-        bridgeInfo[targetChainId] = info.tokenAddress;
-      }
-      return {
-        data: bridgeInfo
-      };
-    } catch (error) {
-      throw new Error(error instanceof Error ? error.message : "Unknown error");
-    }
-  }
-  /**
-   * Fetch the Uniswap token list
-   */
-  async fetchTokenList() {
-    const now = Date.now();
-    if (this.tokenListCache && now - this.lastFetch < this.CACHE_DURATION) {
-      return this.tokenListCache;
-    }
-    try {
-      const response = await fetch(this.UNISWAP_TOKEN_LIST_URL, {
-        headers: {
-          Accept: "application/json"
-        }
-      });
-      if (!response.ok) {
-        throw new Error(`IPFS fetch failed: ${response.status}`);
-      }
-      const data = await response.json();
-      this.tokenListCache = data;
-      this.lastFetch = now;
-      return data;
-    } catch (error) {
-      logger.logError(error, {
-        context: this.fetchTokenList.name
-      });
-      try {
-        const response = await fetch(this.FALLBACK_URL, {
-          headers: {
-            Accept: "application/json"
-          }
-        });
-        if (!response.ok) {
-          throw new Error(`Fallback fetch failed: ${response.status}`);
-        }
-        const data = await response.json();
-        this.tokenListCache = data;
-        this.lastFetch = now;
-        return data;
-      } catch (fallbackError) {
-        logger.logError(fallbackError, {
-          context: this.fetchTokenList.name
-        });
-        throw new Error("Unable to fetch Uniswap token list");
-      }
-    }
-  }
+	async createSubOrganization() {
+		return await this.makeRequest({
+			url: "/operating_accounts/sub_organization/new",
+			method: HttpMethod.Post,
+			schema: newOperatingAccountSubOrgResponseSchema
+		});
+	}
+	async getSubOrganization() {
+		return await this.makeRequest({
+			url: "/operating_accounts/sub_organization",
+			method: HttpMethod.Get,
+			schema: getOperatingAccountSubOrgResponseSchema
+		});
+	}
 };
 
-// src/api/api.ts
+//#endregion
+//#region src/api/api.ts
 var APIClient = class {
-  constructor(init) {
-    __publicField(this, "account");
-    __publicField(this, "activity");
-    __publicField(this, "auth");
-    __publicField(this, "operatingAccount");
-    __publicField(this, "config");
-    __publicField(this, "contacts");
-    __publicField(this, "developer");
-    __publicField(this, "instruction");
-    __publicField(this, "transaction");
-    __publicField(this, "payments");
-    __publicField(this, "integration");
-    const instance = isInstanceInit(init) ? init.instance : createInstance(init);
-    this.account = new AccountService(instance);
-    this.activity = new ActivityService(instance);
-    this.auth = new AuthService(instance);
-    this.config = new ConfigService(instance);
-    this.contacts = new ContactsService(instance);
-    this.developer = new DeveloperService(instance);
-    this.instruction = new InstructionService(instance);
-    this.integration = new IntegrationService(instance);
-    this.transaction = new TransactionService(instance);
-    this.operatingAccount = new OperatingAccountService(instance);
-    this.payments = new PaymentsService(instance);
-  }
+	constructor(init) {
+		require_defineProperty._defineProperty(this, "account", void 0);
+		require_defineProperty._defineProperty(this, "activity", void 0);
+		require_defineProperty._defineProperty(this, "auth", void 0);
+		require_defineProperty._defineProperty(this, "operatingAccount", void 0);
+		require_defineProperty._defineProperty(this, "config", void 0);
+		require_defineProperty._defineProperty(this, "contacts", void 0);
+		require_defineProperty._defineProperty(this, "developer", void 0);
+		require_defineProperty._defineProperty(this, "instruction", void 0);
+		require_defineProperty._defineProperty(this, "transaction", void 0);
+		require_defineProperty._defineProperty(this, "payments", void 0);
+		require_defineProperty._defineProperty(this, "integration", void 0);
+		const instance = isInstanceInit(init) ? init.instance : createInstance({
+			...init,
+			baseURL: init?.environment ? require_api_urls.getOffchainApiUrl(init.environment) : init?.baseURL
+		});
+		this.account = new AccountService(instance);
+		this.activity = new ActivityService(instance);
+		this.auth = new AuthService(instance);
+		this.config = new ConfigService(instance);
+		this.contacts = new ContactsService(instance);
+		this.developer = new DeveloperService(instance);
+		this.instruction = new InstructionService(instance);
+		this.integration = new IntegrationService(instance);
+		this.transaction = new TransactionService(instance);
+		this.operatingAccount = new OperatingAccountService(instance);
+		this.payments = new PaymentsService(instance);
+	}
+};
+const createAPIClient = (...params) => {
+	return new APIClient(...params);
 };
-var createAPIClient = (...params) => {
-  return new APIClient(...params);
+
+//#endregion
+//#region src/api/result.ts
+function success(data) {
+	return {
+		success: true,
+		data
+	};
+}
+function failure(error, code) {
+	return {
+		success: false,
+		error,
+		code
+	};
+}
+function isSuccess(result) {
+	return result.success === true;
+}
+function isFailure(result) {
+	return result.success === false;
+}
+const ErrorCode = {
+	NetworkError: "NETWORK_ERROR",
+	Unauthorized: "UNAUTHORIZED",
+	AuthenticationFailed: "AUTH_FAILED",
+	MissingParameter: "MISSING_PARAMETER",
+	Forbidden: "FORBIDDEN",
+	SessionExpired: "SESSION_EXPIRED",
+	InvalidInput: "INVALID_INPUT",
+	UnknownError: "UNKNOWN_ERROR"
 };
-//# sourceMappingURL=index.js.map
+
+//#endregion
+exports.APIClient = APIClient;
+exports.AccountService = AccountService;
+exports.ActivityService = ActivityService;
+exports.AuthService = AuthService;
+exports.ConfigService = ConfigService;
+exports.ContactsService = ContactsService;
+exports.DelegationStatus = DelegationStatus;
+exports.DeveloperService = DeveloperService;
+exports.ErrorCode = ErrorCode;
+exports.HttpMethod = HttpMethod;
+exports.InstructionService = InstructionService;
+exports.IntegrationService = IntegrationService;
+exports.IntegrationType = IntegrationType;
+exports.OperatingAccountService = OperatingAccountService;
+exports.PaymentsService = PaymentsService;
+exports.ServiceError = ServiceError;
+exports.TransactionService = TransactionService;
+exports.actionArgumentsResponseSchema = actionArgumentsResponseSchema;
+exports.actionArgumentsSchema = actionArgumentsSchema;
+exports.actionNameSchema = actionNameSchema;
+exports.activityDataSchema = activityDataSchema;
+exports.activityRecordSchema = activityRecordSchema;
+exports.addressWhitelistCheckRequestSchema = addressWhitelistCheckRequestSchema;
+exports.addressWhitelistCheckResponseSchema = addressWhitelistCheckResponseSchema;
+exports.apiErrorSchema = apiErrorSchema;
+exports.attestationSchema = attestationSchema;
+exports.authLoginRequestSchema = authLoginRequestSchema;
+exports.authLoginResponseSchema = authLoginResponseSchema;
+exports.buildEphemeralInstructionSchema = buildEphemeralInstructionSchema;
+exports.buildSettlementRequestSchema = buildSettlementRequestSchema;
+exports.buildSettlementResponseSchema = buildSettlementResponseSchema;
+exports.calculateBackoffInterval = calculateBackoffInterval;
+exports.calculateHasMore = calculateHasMore;
+exports.chainIdSchema = chainIdSchema;
+exports.chainSuccessResponseSchema = chainSuccessResponseSchema;
+exports.contactSchema = contactSchema;
+exports.createAPIClient = createAPIClient;
+exports.createAbortController = createAbortController;
+exports.createInstance = createInstance;
+exports.delegationCreateRequestSchema = delegationCreateRequestSchema;
+exports.delegationCreateResponseSchema = delegationCreateResponseSchema;
+exports.delegationStatusRequestSchema = delegationStatusRequestSchema;
+exports.delegationStatusResponseSchema = delegationStatusResponseSchema;
+exports.delegationStatusSchema = delegationStatusSchema;
+exports.delegationStatusValues = delegationStatusValues;
+exports.errorResponseSchema = errorResponseSchema;
+exports.extractPaginationParams = extractPaginationParams;
+exports.failure = failure;
+exports.feeResponseSchema = feeResponseSchema;
+exports.formatActionName = formatActionName;
+exports.formatPaymentRail = formatPaymentRail;
+exports.getConfigChainsResponseSchema = getConfigChainsResponseSchema;
+exports.getConfigTokensRequestParametersSchema = getConfigTokensRequestParametersSchema;
+exports.getConfigTokensResponseSchema = getConfigTokensResponseSchema;
+exports.getContactsRequestSchema = getContactsRequestSchema;
+exports.getContactsResponseSchema = getContactsResponseSchema;
+exports.getDefaultPagination = getDefaultPagination;
+exports.getDelegateAddressResponseSchema = getDelegateAddressResponseSchema;
+exports.getDelegateAddressSchema = getDelegateAddressSchema;
+exports.getErrorMessage = getErrorMessage;
+exports.getErrorMessageWithCode = getErrorMessageWithCode;
+exports.getInstructionActivityRequestSchema = getInstructionActivityRequestSchema;
+exports.getInstructionActivityResponseSchema = getInstructionActivityResponseSchema;
+exports.getIntegrationRequestSchema = getIntegrationRequestSchema;
+exports.getMaxPriorityFeePerGasEstimateResponseSchema = getMaxPriorityFeePerGasEstimateResponseSchema;
+exports.getMaxPriorityFeePerGasEstimateSchema = getMaxPriorityFeePerGasEstimateSchema;
+exports.getOperatingAccountSubOrgResponseSchema = getOperatingAccountSubOrgResponseSchema;
+exports.getPaymentRequestsRequestSchema = getPaymentRequestsRequestSchema;
+exports.getPaymentRequestsResponseSchema = getPaymentRequestsResponseSchema;
+exports.getUserFriendlyErrorMessage = getUserFriendlyErrorMessage;
+exports.instructionActivateRequestSchema = instructionActivateRequestSchema;
+exports.instructionActivateResponseSchema = instructionActivateResponseSchema;
+exports.instructionBuildRequestSchema = instructionBuildRequestSchema;
+exports.instructionBuildSchema = instructionBuildSchema;
+exports.instructionDeactivateRequestSchema = instructionDeactivateRequestSchema;
+exports.instructionDeactivateResponseSchema = instructionDeactivateResponseSchema;
+exports.instructionDetailsRequestSchema = instructionDetailsRequestSchema;
+exports.instructionDetailsResponseSchema = instructionDetailsResponseSchema;
+exports.instructionGetAllRequestSchema = instructionGetAllRequestSchema;
+exports.instructionGetAllResponseSchema = instructionGetAllResponseSchema;
+exports.instructionGetRulesRequestSchema = instructionGetRulesRequestSchema;
+exports.instructionGetRulesResponseSchema = instructionGetRulesResponseSchema;
+exports.integrationResponseSchema = integrationResponseSchema;
+exports.integrationTypeSchema = integrationTypeSchema;
+exports.integrationTypeValues = integrationTypeValues;
+exports.isFailure = isFailure;
+exports.isInstanceInit = isInstanceInit;
+exports.isSuccess = isSuccess;
+exports.isTechnicalError = isTechnicalError;
+exports.isUserAddressableError = isUserAddressableError;
+exports.isUserRejectionError = isUserRejectionError;
+exports.meResponseSchema = meResponseSchema;
+exports.newContactRequestSchema = newContactRequestSchema;
+exports.newInstructionRequestSchema = newInstructionRequestSchema;
+exports.newOperatingAccountSubOrgResponseSchema = newOperatingAccountSubOrgResponseSchema;
+exports.orchestrationTypeSchema = orchestrationTypeSchema;
+exports.paymentRequestBuildRequestSchema = paymentRequestBuildRequestSchema;
+exports.paymentRequestBuildResponseSchema = paymentRequestBuildResponseSchema;
+exports.paymentRequestDetailsRequestSchema = paymentRequestDetailsRequestSchema;
+exports.paymentRequestDetailsResponseSchema = paymentRequestDetailsResponseSchema;
+exports.paymentRequestNewRequestSchema = paymentRequestNewRequestSchema;
+exports.paymentRequestSchema = paymentRequestSchema;
+exports.paymentRequestStatusSchema = paymentRequestStatusSchema;
+exports.paymentRequestsDirectionSchema = paymentRequestsDirectionSchema;
+exports.sessionTokenRequestSchema = sessionTokenRequestSchema;
+exports.sessionTokenResponseSchema = sessionTokenResponseSchema;
+exports.sessionVerifyResponseSchema = sessionVerifyResponseSchema;
+exports.setChainIdSchema = setChainIdSchema;
+exports.success = success;
+exports.transactionGetListRequestSchema = transactionGetListRequestSchema;
+exports.transactionGetListResponseSchema = transactionGetListResponseSchema;
+exports.turnkeyLoginRequestSchema = turnkeyLoginRequestSchema;
+exports.turnkeyLoginResponseSchema = turnkeyLoginResponseSchema;
+exports.turnkeyVerificationRequestSchema = turnkeyVerificationRequestSchema;
+exports.turnkeyVerificationResponseSchema = turnkeyVerificationResponseSchema;
+exports.updateIntegrationRequestSchema = updateIntegrationRequestSchema;
+exports.whitelistCheckRequestSchema = whitelistCheckRequestSchema;
+exports.whitelistCheckResponseSchema = whitelistCheckResponseSchema;
+//# sourceMappingURL=index.js.map